/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using FilterBackpropWindow5Stride1 = WindowStrideTest<Pair, 5, 1>;
TYPED_TEST_SUITE(FilterBackpropWindow5Stride1, GTestTypeTriples);
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5432.,  6940.,  8500.,  7180.,  5816.,  7990.,  10100., 12245., 10250.,
      8230.,  10740., 13470., 16206., 13470., 10740., 8230.,  10250., 12245.,
      10100., 7990.,  5816.,  7180.,  8500.,  6940.,  5432.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58.,  68.,  78.,  88.,  98.,  118., 128., 138., 148.,
      158., 178., 188., 198., 208., 218., 238., 248., 258.,
      268., 278., 298., 308., 318., 328., 338.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10680., 10864., 13640., 13880., 16700., 17000., 14100., 14360., 11416.,
      11632., 15690., 15980., 19825., 20200., 24025., 24490., 20100., 20500.,
      16130., 16460., 21060., 21480., 26400., 26940., 31746., 32412., 26370.,
      26940., 21012., 21480., 16050., 16460., 19975., 20500., 23845., 24490.,
      19650., 20200., 15530., 15980., 11256., 11632., 13880., 14360., 16412.,
      17000., 13380., 13880., 10456., 10864.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      98.,  116., 114., 136., 130., 156., 146., 176., 162., 196.,
      194., 236., 210., 256., 226., 276., 242., 296., 258., 316.,
      290., 356., 306., 376., 322., 396., 338., 416., 354., 436.,
      386., 476., 402., 496., 418., 516., 434., 536., 450., 556.,
      482., 596., 498., 616., 514., 636., 530., 656., 546., 676.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21176., 21360., 21544., 21728., 27040., 27280., 27520., 27760., 33100.,
      33400., 33700., 34000., 27940., 28200., 28460., 28720., 22616., 22832.,
      23048., 23264., 31090., 31380., 31670., 31960., 39275., 39650., 40025.,
      40400., 47585., 48050., 48515., 48980., 39800., 40200., 40600., 41000.,
      31930., 32260., 32590., 32920., 41700., 42120., 42540., 42960., 52260.,
      52800., 53340., 53880., 62826., 63492., 64158., 64824., 52170., 52740.,
      53310., 53880., 41556., 42024., 42492., 42960., 31690., 32100., 32510.,
      32920., 39425., 39950., 40475., 41000., 47045., 47690., 48335., 48980.,
      38750., 39300., 39850., 40400., 30610., 31060., 31510., 31960., 22136.,
      22512., 22888., 23264., 27280., 27760., 28240., 28720., 32236., 32824.,
      33412., 34000., 26260., 26760., 27260., 27760., 20504., 20912., 21320.,
      21728.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      178.,  196.,  214.,  232.,  206.,  228.,  250.,  272.,  234.,  260.,
      286.,  312.,  262.,  292.,  322.,  352.,  290.,  324.,  358.,  392.,
      346.,  388.,  430.,  472.,  374.,  420.,  466.,  512.,  402.,  452.,
      502.,  552.,  430.,  484.,  538.,  592.,  458.,  516.,  574.,  632.,
      514.,  580.,  646.,  712.,  542.,  612.,  682.,  752.,  570.,  644.,
      718.,  792.,  598.,  676.,  754.,  832.,  626.,  708.,  790.,  872.,
      682.,  772.,  862.,  952.,  710.,  804.,  898.,  992.,  738.,  836.,
      934.,  1032., 766.,  868.,  970.,  1072., 794.,  900.,  1006., 1112.,
      850.,  964.,  1078., 1192., 878.,  996.,  1114., 1232., 906.,  1028.,
      1150., 1272., 934.,  1060., 1186., 1312., 962.,  1092., 1222., 1352.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10456., 10864., 13380., 13880., 16412., 17000., 13880., 14360., 11256.,
      11632., 15530., 15980., 19650., 20200., 23845., 24490., 19975., 20500.,
      16050., 16460., 21012., 21480., 26370., 26940., 31746., 32412., 26400.,
      26940., 21060., 21480., 16130., 16460., 20100., 20500., 24025., 24490.,
      19825., 20200., 15690., 15980., 11416., 11632., 14100., 14360., 16700.,
      17000., 13640., 13880., 10680., 10864.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      106., 116., 126., 136., 146., 156., 166., 176., 186., 196.,
      226., 236., 246., 256., 266., 276., 286., 296., 306., 316.,
      346., 356., 366., 376., 386., 396., 406., 416., 426., 436.,
      466., 476., 486., 496., 506., 516., 526., 536., 546., 556.,
      586., 596., 606., 616., 626., 636., 646., 656., 666., 676.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20560., 20912., 21360., 21728., 26300., 26760., 27280., 27760., 32248.,
      32824., 33400., 34000., 27260., 27760., 28200., 28720., 22096., 22512.,
      22832., 23264., 30500., 31060., 31380., 31960., 38575., 39300., 39650.,
      40400., 46790., 47690., 48050., 48980., 39175., 39950., 40200., 41000.,
      31460., 32100., 32260., 32920., 41208., 42024., 42120., 42960., 51690.,
      52740., 52800., 53880., 62196., 63492., 63492., 64824., 51690., 52800.,
      52740., 53880., 41208., 42120., 42024., 42960., 31460., 32260., 32100.,
      32920., 39175., 40200., 39950., 41000., 46790., 48050., 47690., 48980.,
      38575., 39650., 39300., 40400., 30500., 31380., 31060., 31960., 22096.,
      22832., 22512., 23264., 27260., 28200., 27760., 28720., 32248., 33400.,
      32824., 34000., 26300., 27280., 26760., 27760., 20560., 21360., 20912.,
      21728.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      180.,  212.,  196.,  232.,  212.,  252.,  228.,  272.,  244.,  292.,
      260.,  312.,  276.,  332.,  292.,  352.,  308.,  372.,  324.,  392.,
      372.,  452.,  388.,  472.,  404.,  492.,  420.,  512.,  436.,  532.,
      452.,  552.,  468.,  572.,  484.,  592.,  500.,  612.,  516.,  632.,
      564.,  692.,  580.,  712.,  596.,  732.,  612.,  752.,  628.,  772.,
      644.,  792.,  660.,  812.,  676.,  832.,  692.,  852.,  708.,  872.,
      756.,  932.,  772.,  952.,  788.,  972.,  804.,  992.,  820.,  1012.,
      836.,  1032., 852.,  1052., 868.,  1072., 884.,  1092., 900.,  1112.,
      948.,  1172., 964.,  1192., 980.,  1212., 996.,  1232., 1012., 1252.,
      1028., 1272., 1044., 1292., 1060., 1312., 1076., 1332., 1092., 1352.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40768.,  41120.,  41472.,  41824.,  42352.,  42720.,  43088.,  43456.,
      52140.,  52600.,  53060.,  53520.,  54080.,  54560.,  55040.,  55520.,
      63920.,  64496.,  65072.,  65648.,  66200.,  66800.,  67400.,  68000.,
      54020.,  54520.,  55020.,  55520.,  55880.,  56400.,  56920.,  57440.,
      43776.,  44192.,  44608.,  45024.,  45232.,  45664.,  46096.,  46528.,
      60440.,  61000.,  61560.,  62120.,  62180.,  62760.,  63340.,  63920.,
      76425.,  77150.,  77875.,  78600.,  78550.,  79300.,  80050.,  80800.,
      92680.,  93580.,  94480.,  95380.,  95170.,  96100.,  97030.,  97960.,
      77575.,  78350.,  79125.,  79900.,  79600.,  80400.,  81200.,  82000.,
      62280.,  62920.,  63560.,  64200.,  63860.,  64520.,  65180.,  65840.,
      81600.,  82416.,  83232.,  84048.,  83400.,  84240.,  85080.,  85920.,
      102330., 103380., 104430., 105480., 104520., 105600., 106680., 107760.,
      123096., 124392., 125688., 126984., 125652., 126984., 128316., 129648.,
      102270., 103380., 104490., 105600., 104340., 105480., 106620., 107760.,
      81504.,  82416.,  83328.,  84240.,  83112.,  84048.,  84984.,  85920.,
      62120.,  62920.,  63720.,  64520.,  63380.,  64200.,  65020.,  65840.,
      77325.,  78350.,  79375.,  80400.,  78850.,  79900.,  80950.,  82000.,
      92320.,  93580.,  94840.,  96100.,  94090.,  95380.,  96670.,  97960.,
      76075.,  77150.,  78225.,  79300.,  77500.,  78600.,  79700.,  80800.,
      60120.,  61000.,  61880.,  62760.,  61220.,  62120.,  63020.,  63920.,
      43456.,  44192.,  44928.,  45664.,  44272.,  45024.,  45776.,  46528.,
      53580.,  54520.,  55460.,  56400.,  54560.,  55520.,  56480.,  57440.,
      63344.,  64496.,  65648.,  66800.,  64472.,  65648.,  66824.,  68000.,
      51620.,  52600.,  53580.,  54560.,  52520.,  53520.,  54520.,  55520.,
      40320.,  41120.,  41920.,  42720.,  41008.,  41824.,  42640.,  43456.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      328.,  360.,  392.,  424.,  356.,  392.,  428.,  464.,  384.,  424.,
      464.,  504.,  412.,  456.,  500.,  544.,  440.,  488.,  536.,  584.,
      468.,  520.,  572.,  624.,  496.,  552.,  608.,  664.,  524.,  584.,
      644.,  704.,  552.,  616.,  680.,  744.,  580.,  648.,  716.,  784.,
      664.,  744.,  824.,  904.,  692.,  776.,  860.,  944.,  720.,  808.,
      896.,  984.,  748.,  840.,  932.,  1024., 776.,  872.,  968.,  1064.,
      804.,  904.,  1004., 1104., 832.,  936.,  1040., 1144., 860.,  968.,
      1076., 1184., 888.,  1000., 1112., 1224., 916.,  1032., 1148., 1264.,
      1000., 1128., 1256., 1384., 1028., 1160., 1292., 1424., 1056., 1192.,
      1328., 1464., 1084., 1224., 1364., 1504., 1112., 1256., 1400., 1544.,
      1140., 1288., 1436., 1584., 1168., 1320., 1472., 1624., 1196., 1352.,
      1508., 1664., 1224., 1384., 1544., 1704., 1252., 1416., 1580., 1744.,
      1336., 1512., 1688., 1864., 1364., 1544., 1724., 1904., 1392., 1576.,
      1760., 1944., 1420., 1608., 1796., 1984., 1448., 1640., 1832., 2024.,
      1476., 1672., 1868., 2064., 1504., 1704., 1904., 2104., 1532., 1736.,
      1940., 2144., 1560., 1768., 1976., 2184., 1588., 1800., 2012., 2224.,
      1672., 1896., 2120., 2344., 1700., 1928., 2156., 2384., 1728., 1960.,
      2192., 2424., 1756., 1992., 2228., 2464., 1784., 2024., 2264., 2504.,
      1812., 2056., 2300., 2544., 1840., 2088., 2336., 2584., 1868., 2120.,
      2372., 2624., 1896., 2152., 2408., 2664., 1924., 2184., 2444., 2704.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20504., 20912., 21320., 21728., 26260., 26760., 27260., 27760., 32236.,
      32824., 33412., 34000., 27280., 27760., 28240., 28720., 22136., 22512.,
      22888., 23264., 30610., 31060., 31510., 31960., 38750., 39300., 39850.,
      40400., 47045., 47690., 48335., 48980., 39425., 39950., 40475., 41000.,
      31690., 32100., 32510., 32920., 41556., 42024., 42492., 42960., 52170.,
      52740., 53310., 53880., 62826., 63492., 64158., 64824., 52260., 52800.,
      53340., 53880., 41700., 42120., 42540., 42960., 31930., 32260., 32590.,
      32920., 39800., 40200., 40600., 41000., 47585., 48050., 48515., 48980.,
      39275., 39650., 40025., 40400., 31090., 31380., 31670., 31960., 22616.,
      22832., 23048., 23264., 27940., 28200., 28460., 28720., 33100., 33400.,
      33700., 34000., 27040., 27280., 27520., 27760., 21176., 21360., 21544.,
      21728.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      202.,  212.,  222.,  232.,  242.,  252.,  262.,  272.,  282.,  292.,
      302.,  312.,  322.,  332.,  342.,  352.,  362.,  372.,  382.,  392.,
      442.,  452.,  462.,  472.,  482.,  492.,  502.,  512.,  522.,  532.,
      542.,  552.,  562.,  572.,  582.,  592.,  602.,  612.,  622.,  632.,
      682.,  692.,  702.,  712.,  722.,  732.,  742.,  752.,  762.,  772.,
      782.,  792.,  802.,  812.,  822.,  832.,  842.,  852.,  862.,  872.,
      922.,  932.,  942.,  952.,  962.,  972.,  982.,  992.,  1002., 1012.,
      1022., 1032., 1042., 1052., 1062., 1072., 1082., 1092., 1102., 1112.,
      1162., 1172., 1182., 1192., 1202., 1212., 1222., 1232., 1242., 1252.,
      1262., 1272., 1282., 1292., 1302., 1312., 1322., 1332., 1342., 1352.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      40320.,  41008.,  41120.,  41824.,  41920.,  42640.,  42720.,  43456.,
      51620.,  52520.,  52600.,  53520.,  53580.,  54520.,  54560.,  55520.,
      63344.,  64472.,  64496.,  65648.,  65648.,  66824.,  66800.,  68000.,
      53580.,  54560.,  54520.,  55520.,  55460.,  56480.,  56400.,  57440.,
      43456.,  44272.,  44192.,  45024.,  44928.,  45776.,  45664.,  46528.,
      60120.,  61220.,  61000.,  62120.,  61880.,  63020.,  62760.,  63920.,
      76075.,  77500.,  77150.,  78600.,  78225.,  79700.,  79300.,  80800.,
      92320.,  94090.,  93580.,  95380.,  94840.,  96670.,  96100.,  97960.,
      77325.,  78850.,  78350.,  79900.,  79375.,  80950.,  80400.,  82000.,
      62120.,  63380.,  62920.,  64200.,  63720.,  65020.,  64520.,  65840.,
      81504.,  83112.,  82416.,  84048.,  83328.,  84984.,  84240.,  85920.,
      102270., 104340., 103380., 105480., 104490., 106620., 105600., 107760.,
      123096., 125652., 124392., 126984., 125688., 128316., 126984., 129648.,
      102330., 104520., 103380., 105600., 104430., 106680., 105480., 107760.,
      81600.,  83400.,  82416.,  84240.,  83232.,  85080.,  84048.,  85920.,
      62280.,  63860.,  62920.,  64520.,  63560.,  65180.,  64200.,  65840.,
      77575.,  79600.,  78350.,  80400.,  79125.,  81200.,  79900.,  82000.,
      92680.,  95170.,  93580.,  96100.,  94480.,  97030.,  95380.,  97960.,
      76425.,  78550.,  77150.,  79300.,  77875.,  80050.,  78600.,  80800.,
      60440.,  62180.,  61000.,  62760.,  61560.,  63340.,  62120.,  63920.,
      43776.,  45232.,  44192.,  45664.,  44608.,  46096.,  45024.,  46528.,
      54020.,  55880.,  54520.,  56400.,  55020.,  56920.,  55520.,  57440.,
      63920.,  66200.,  64496.,  66800.,  65072.,  67400.,  65648.,  68000.,
      52140.,  54080.,  52600.,  54560.,  53060.,  55040.,  53520.,  55520.,
      40768.,  42352.,  41120.,  42720.,  41472.,  43088.,  41824.,  43456.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344.,  404.,  360.,  424.,  376.,  444.,  392.,  464.,  408.,  484.,
      424.,  504.,  440.,  524.,  456.,  544.,  472.,  564.,  488.,  584.,
      504.,  604.,  520.,  624.,  536.,  644.,  552.,  664.,  568.,  684.,
      584.,  704.,  600.,  724.,  616.,  744.,  632.,  764.,  648.,  784.,
      728.,  884.,  744.,  904.,  760.,  924.,  776.,  944.,  792.,  964.,
      808.,  984.,  824.,  1004., 840.,  1024., 856.,  1044., 872.,  1064.,
      888.,  1084., 904.,  1104., 920.,  1124., 936.,  1144., 952.,  1164.,
      968.,  1184., 984.,  1204., 1000., 1224., 1016., 1244., 1032., 1264.,
      1112., 1364., 1128., 1384., 1144., 1404., 1160., 1424., 1176., 1444.,
      1192., 1464., 1208., 1484., 1224., 1504., 1240., 1524., 1256., 1544.,
      1272., 1564., 1288., 1584., 1304., 1604., 1320., 1624., 1336., 1644.,
      1352., 1664., 1368., 1684., 1384., 1704., 1400., 1724., 1416., 1744.,
      1496., 1844., 1512., 1864., 1528., 1884., 1544., 1904., 1560., 1924.,
      1576., 1944., 1592., 1964., 1608., 1984., 1624., 2004., 1640., 2024.,
      1656., 2044., 1672., 2064., 1688., 2084., 1704., 2104., 1720., 2124.,
      1736., 2144., 1752., 2164., 1768., 2184., 1784., 2204., 1800., 2224.,
      1880., 2324., 1896., 2344., 1912., 2364., 1928., 2384., 1944., 2404.,
      1960., 2424., 1976., 2444., 1992., 2464., 2008., 2484., 2024., 2504.,
      2040., 2524., 2056., 2544., 2072., 2564., 2088., 2584., 2104., 2604.,
      2120., 2624., 2136., 2644., 2152., 2664., 2168., 2684., 2184., 2704.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      79952.,  80640.,  81328.,  82016.,  81536.,  82240.,  82944.,  83648.,
      83120.,  83840.,  84560.,  85280.,  84704.,  85440.,  86176.,  86912.,
      102340., 103240., 104140., 105040., 104280., 105200., 106120., 107040.,
      106220., 107160., 108100., 109040., 108160., 109120., 110080., 111040.,
      125560., 126688., 127816., 128944., 127840., 128992., 130144., 131296.,
      130120., 131296., 132472., 133648., 132400., 133600., 134800., 136000.,
      106180., 107160., 108140., 109120., 108040., 109040., 110040., 111040.,
      109900., 110920., 111940., 112960., 111760., 112800., 113840., 114880.,
      86096.,  86912.,  87728.,  88544.,  87552.,  88384.,  89216.,  90048.,
      89008.,  89856.,  90704.,  91552.,  90464.,  91328.,  92192.,  93056.,
      119140., 120240., 121340., 122440., 120880., 122000., 123120., 124240.,
      122620., 123760., 124900., 126040., 124360., 125520., 126680., 127840.,
      150725., 152150., 153575., 155000., 152850., 154300., 155750., 157200.,
      154975., 156450., 157925., 159400., 157100., 158600., 160100., 161600.,
      182870., 184640., 186410., 188180., 185360., 187160., 188960., 190760.,
      187850., 189680., 191510., 193340., 190340., 192200., 194060., 195920.,
      153125., 154650., 156175., 157700., 155150., 156700., 158250., 159800.,
      157175., 158750., 160325., 161900., 159200., 160800., 162400., 164000.,
      122980., 124240., 125500., 126760., 124560., 125840., 127120., 128400.,
      126140., 127440., 128740., 130040., 127720., 129040., 130360., 131680.,
      161400., 163008., 164616., 166224., 163200., 164832., 166464., 168096.,
      165000., 166656., 168312., 169968., 166800., 168480., 170160., 171840.,
      202470., 204540., 206610., 208680., 204660., 206760., 208860., 210960.,
      206850., 208980., 211110., 213240., 209040., 211200., 213360., 215520.,
      243636., 246192., 248748., 251304., 246192., 248784., 251376., 253968.,
      248748., 251376., 254004., 256632., 251304., 253968., 256632., 259296.,
      202470., 204660., 206850., 209040., 204540., 206760., 208980., 211200.,
      206610., 208860., 211110., 213360., 208680., 210960., 213240., 215520.,
      161400., 163200., 165000., 166800., 163008., 164832., 166656., 168480.,
      164616., 166464., 168312., 170160., 166224., 168096., 169968., 171840.,
      122980., 124560., 126140., 127720., 124240., 125840., 127440., 129040.,
      125500., 127120., 128740., 130360., 126760., 128400., 130040., 131680.,
      153125., 155150., 157175., 159200., 154650., 156700., 158750., 160800.,
      156175., 158250., 160325., 162400., 157700., 159800., 161900., 164000.,
      182870., 185360., 187850., 190340., 184640., 187160., 189680., 192200.,
      186410., 188960., 191510., 194060., 188180., 190760., 193340., 195920.,
      150725., 152850., 154975., 157100., 152150., 154300., 156450., 158600.,
      153575., 155750., 157925., 160100., 155000., 157200., 159400., 161600.,
      119140., 120880., 122620., 124360., 120240., 122000., 123760., 125520.,
      121340., 123120., 124900., 126680., 122440., 124240., 126040., 127840.,
      86096.,  87552.,  89008.,  90464.,  86912.,  88384.,  89856.,  91328.,
      87728.,  89216.,  90704.,  92192.,  88544.,  90048.,  91552.,  93056.,
      106180., 108040., 109900., 111760., 107160., 109040., 110920., 112800.,
      108140., 110040., 111940., 113840., 109120., 111040., 112960., 114880.,
      125560., 127840., 130120., 132400., 126688., 128992., 131296., 133600.,
      127816., 130144., 132472., 134800., 128944., 131296., 133648., 136000.,
      102340., 104280., 106220., 108160., 103240., 105200., 107160., 109120.,
      104140., 106120., 108100., 110080., 105040., 107040., 109040., 111040.,
      79952.,  81536.,  83120.,  84704.,  80640.,  82240.,  83840.,  85440.,
      81328.,  82944.,  84560.,  86176.,  82016.,  83648.,  85280.,  86912.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      628.,  688.,  748.,  808.,  656.,  720.,  784.,  848.,  684.,  752.,
      820.,  888.,  712.,  784.,  856.,  928.,  740.,  816.,  892.,  968.,
      768.,  848.,  928.,  1008., 796.,  880.,  964.,  1048., 824.,  912.,
      1000., 1088., 852.,  944.,  1036., 1128., 880.,  976.,  1072., 1168.,
      908.,  1008., 1108., 1208., 936.,  1040., 1144., 1248., 964.,  1072.,
      1180., 1288., 992.,  1104., 1216., 1328., 1020., 1136., 1252., 1368.,
      1048., 1168., 1288., 1408., 1076., 1200., 1324., 1448., 1104., 1232.,
      1360., 1488., 1132., 1264., 1396., 1528., 1160., 1296., 1432., 1568.,
      1300., 1456., 1612., 1768., 1328., 1488., 1648., 1808., 1356., 1520.,
      1684., 1848., 1384., 1552., 1720., 1888., 1412., 1584., 1756., 1928.,
      1440., 1616., 1792., 1968., 1468., 1648., 1828., 2008., 1496., 1680.,
      1864., 2048., 1524., 1712., 1900., 2088., 1552., 1744., 1936., 2128.,
      1580., 1776., 1972., 2168., 1608., 1808., 2008., 2208., 1636., 1840.,
      2044., 2248., 1664., 1872., 2080., 2288., 1692., 1904., 2116., 2328.,
      1720., 1936., 2152., 2368., 1748., 1968., 2188., 2408., 1776., 2000.,
      2224., 2448., 1804., 2032., 2260., 2488., 1832., 2064., 2296., 2528.,
      1972., 2224., 2476., 2728., 2000., 2256., 2512., 2768., 2028., 2288.,
      2548., 2808., 2056., 2320., 2584., 2848., 2084., 2352., 2620., 2888.,
      2112., 2384., 2656., 2928., 2140., 2416., 2692., 2968., 2168., 2448.,
      2728., 3008., 2196., 2480., 2764., 3048., 2224., 2512., 2800., 3088.,
      2252., 2544., 2836., 3128., 2280., 2576., 2872., 3168., 2308., 2608.,
      2908., 3208., 2336., 2640., 2944., 3248., 2364., 2672., 2980., 3288.,
      2392., 2704., 3016., 3328., 2420., 2736., 3052., 3368., 2448., 2768.,
      3088., 3408., 2476., 2800., 3124., 3448., 2504., 2832., 3160., 3488.,
      2644., 2992., 3340., 3688., 2672., 3024., 3376., 3728., 2700., 3056.,
      3412., 3768., 2728., 3088., 3448., 3808., 2756., 3120., 3484., 3848.,
      2784., 3152., 3520., 3888., 2812., 3184., 3556., 3928., 2840., 3216.,
      3592., 3968., 2868., 3248., 3628., 4008., 2896., 3280., 3664., 4048.,
      2924., 3312., 3700., 4088., 2952., 3344., 3736., 4128., 2980., 3376.,
      3772., 4168., 3008., 3408., 3808., 4208., 3036., 3440., 3844., 4248.,
      3064., 3472., 3880., 4288., 3092., 3504., 3916., 4328., 3120., 3536.,
      3952., 4368., 3148., 3568., 3988., 4408., 3176., 3600., 4024., 4448.,
      3316., 3760., 4204., 4648., 3344., 3792., 4240., 4688., 3372., 3824.,
      4276., 4728., 3400., 3856., 4312., 4768., 3428., 3888., 4348., 4808.,
      3456., 3920., 4384., 4848., 3484., 3952., 4420., 4888., 3512., 3984.,
      4456., 4928., 3540., 4016., 4492., 4968., 3568., 4048., 4528., 5008.,
      3596., 4080., 4564., 5048., 3624., 4112., 4600., 5088., 3652., 4144.,
      4636., 5128., 3680., 4176., 4672., 5168., 3708., 4208., 4708., 5208.,
      3736., 4240., 4744., 5248., 3764., 4272., 4780., 5288., 3792., 4304.,
      4816., 5328., 3820., 4336., 4852., 5368., 3848., 4368., 4888., 5408.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9230.,  11284., 13398., 11620., 9790.,  13550., 16415., 19320., 16625.,
      13900., 18185., 21882., 25585., 21882., 18185., 13900., 16625., 19320.,
      16415., 13550., 9790.,  11620., 13398., 11284., 9230.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      151., 172., 193., 214., 235., 298., 319., 340., 361.,
      382., 445., 466., 487., 508., 529., 592., 613., 634.,
      655., 676., 739., 760., 781., 802., 823.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18190., 18460., 22232., 22568., 26390., 26796., 22880., 23240., 19270.,
      19580., 26675., 27100., 32305., 32830., 38010., 38640., 32695., 33250.,
      27325., 27800., 35755., 36370., 43008., 43764., 50267., 51170., 42972.,
      43764., 35695., 36370., 27200., 27800., 32515., 33250., 37765., 38640.,
      32065., 32830., 26450., 27100., 19030., 19580., 22568., 23240., 25998.,
      26796., 21872., 22568., 17870., 18460.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      269.,  302.,  305.,  344.,  341.,  386.,  377.,  428.,  413.,  470.,
      521.,  596.,  557.,  638.,  593.,  680.,  629.,  722.,  665.,  764.,
      773.,  890.,  809.,  932.,  845.,  974.,  881.,  1016., 917.,  1058.,
      1025., 1184., 1061., 1226., 1097., 1268., 1133., 1310., 1169., 1352.,
      1277., 1478., 1313., 1520., 1349., 1562., 1385., 1604., 1421., 1646.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      36110., 36380., 36650., 36920., 44128.,  44464.,  44800.,  45136., 52374.,
      52780., 53186., 53592., 45400., 45760.,  46120.,  46480.,  38230., 38540.,
      38850., 39160., 52925., 53350., 53775.,  54200.,  64085.,  64610., 65135.,
      65660., 75390., 76020., 76650., 77280.,  64835.,  65390.,  65945., 66500.,
      54175., 54650., 55125., 55600., 70895.,  71510.,  72125.,  72740., 85260.,
      86016., 86772., 87528., 99631., 100534., 101437., 102340., 85152., 85944.,
      86736., 87528., 70715., 71390., 72065.,  72740.,  53800.,  54400., 55000.,
      55600., 64295., 65030., 65765., 66500.,  74655.,  75530.,  76405., 77280.,
      63365., 64130., 64895., 65660., 52250.,  52900.,  53550.,  54200., 37510.,
      38060., 38610., 39160., 44464., 45136.,  45808.,  46480.,  51198., 51996.,
      52794., 53592., 43048., 43744., 44440.,  45136.,  35150.,  35740., 36330.,
      36920.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      505.,  538.,  571.,  604.,  571.,  610.,  649.,  688.,  637.,  682.,
      727.,  772.,  703.,  754.,  805.,  856.,  769.,  826.,  883.,  940.,
      967.,  1042., 1117., 1192., 1033., 1114., 1195., 1276., 1099., 1186.,
      1273., 1360., 1165., 1258., 1351., 1444., 1231., 1330., 1429., 1528.,
      1429., 1546., 1663., 1780., 1495., 1618., 1741., 1864., 1561., 1690.,
      1819., 1948., 1627., 1762., 1897., 2032., 1693., 1834., 1975., 2116.,
      1891., 2050., 2209., 2368., 1957., 2122., 2287., 2452., 2023., 2194.,
      2365., 2536., 2089., 2266., 2443., 2620., 2155., 2338., 2521., 2704.,
      2353., 2554., 2755., 2956., 2419., 2626., 2833., 3040., 2485., 2698.,
      2911., 3124., 2551., 2770., 2989., 3208., 2617., 2842., 3067., 3292.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17870., 18460., 21872., 22568., 25998., 26796., 22568., 23240., 19030.,
      19580., 26450., 27100., 32065., 32830., 37765., 38640., 32515., 33250.,
      27200., 27800., 35695., 36370., 42972., 43764., 50267., 51170., 43008.,
      43764., 35755., 36370., 27325., 27800., 32695., 33250., 38010., 38640.,
      32305., 32830., 26675., 27100., 19270., 19580., 22880., 23240., 26390.,
      26796., 22232., 22568., 18190., 18460.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      281.,  302.,  323.,  344.,  365.,  386.,  407.,  428.,  449.,  470.,
      575.,  596.,  617.,  638.,  659.,  680.,  701.,  722.,  743.,  764.,
      869.,  890.,  911.,  932.,  953.,  974.,  995.,  1016., 1037., 1058.,
      1163., 1184., 1205., 1226., 1247., 1268., 1289., 1310., 1331., 1352.,
      1457., 1478., 1499., 1520., 1541., 1562., 1583., 1604., 1625., 1646.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35220., 35740., 36380., 36920., 43096.,  43744.,  44464.,  45136., 51212.,
      51996., 52780., 53592., 44440., 45136.,  45760.,  46480.,  37460., 38060.,
      38540., 39160., 52075., 52900., 53350.,  54200.,  63110.,  64130., 64610.,
      65660., 74305., 75530., 76020., 77280.,  63950.,  65030.,  65390., 66500.,
      53475., 54400., 54650., 55600., 70190.,  71390.,  71510.,  72740., 84468.,
      85944., 86016., 87528., 98770., 100534., 100534., 102340., 84468., 86016.,
      85944., 87528., 70190., 71510., 71390.,  72740.,  53475.,  54650., 54400.,
      55600., 63950., 65390., 65030., 66500.,  74305.,  76020.,  75530., 77280.,
      63110., 64610., 64130., 65660., 52075.,  53350.,  52900.,  54200., 37460.,
      38540., 38060., 39160., 44440., 45760.,  45136.,  46480.,  51212., 52780.,
      51996., 53592., 43096., 44464., 43744.,  45136.,  35220.,  36380., 35740.,
      36920.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      502.,  562.,  538.,  604.,  574.,  646.,  610.,  688.,  646.,  730.,
      682.,  772.,  718.,  814.,  754.,  856.,  790.,  898.,  826.,  940.,
      1006., 1150., 1042., 1192., 1078., 1234., 1114., 1276., 1150., 1318.,
      1186., 1360., 1222., 1402., 1258., 1444., 1294., 1486., 1330., 1528.,
      1510., 1738., 1546., 1780., 1582., 1822., 1618., 1864., 1654., 1906.,
      1690., 1948., 1726., 1990., 1762., 2032., 1798., 2074., 1834., 2116.,
      2014., 2326., 2050., 2368., 2086., 2410., 2122., 2452., 2158., 2494.,
      2194., 2536., 2230., 2578., 2266., 2620., 2302., 2662., 2338., 2704.,
      2518., 2914., 2554., 2956., 2590., 2998., 2626., 3040., 2662., 3082.,
      2698., 3124., 2734., 3166., 2770., 3208., 2806., 3250., 2842., 3292.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69920.,  70440.,  70960.,  71480.,  72220.,  72760.,  73300.,  73840.,
      85544.,  86192.,  86840.,  87488.,  88256.,  88928.,  89600.,  90272.,
      101640., 102424., 103208., 103992., 104748., 105560., 106372., 107184.,
      88184.,  88880.,  89576.,  90272.,  90800.,  91520.,  92240.,  92960.,
      74320.,  74920.,  75520.,  76120.,  76460.,  77080.,  77700.,  78320.,
      103325., 104150., 104975., 105800., 105850., 106700., 107550., 108400.,
      125200., 126220., 127240., 128260., 128170., 129220., 130270., 131320.,
      147385., 148610., 149835., 151060., 150780., 152040., 153300., 154560.,
      126820., 127900., 128980., 130060., 129670., 130780., 131890., 133000.,
      106025., 106950., 107875., 108800., 108350., 109300., 110250., 111200.,
      139180., 140380., 141580., 142780., 141790., 143020., 144250., 145480.,
      167460., 168936., 170412., 171888., 170520., 172032., 173544., 175056.,
      195776., 197540., 199304., 201068., 199262., 201068., 202874., 204680.,
      167388., 168936., 170484., 172032., 170304., 171888., 173472., 175056.,
      139060., 140380., 141700., 143020., 141430., 142780., 144130., 145480.,
      105775., 106950., 108125., 109300., 107600., 108800., 110000., 111200.,
      126460., 127900., 129340., 130780., 128590., 130060., 131530., 133000.,
      146895., 148610., 150325., 152040., 149310., 151060., 152810., 154560.,
      124720., 126220., 127720., 129220., 126730., 128260., 129790., 131320.,
      102875., 104150., 105425., 106700., 104500., 105800., 107100., 108400.,
      73840.,  74920.,  76000.,  77080.,  75020.,  76120.,  77220.,  78320.,
      87560.,  88880.,  90200.,  91520.,  88928.,  90272.,  91616.,  92960.,
      100856., 102424., 103992., 105560., 102396., 103992., 105588., 107184.,
      84824.,  86192.,  87560.,  88928.,  86096.,  87488.,  88880.,  90272.,
      69280.,  70440.,  71600.,  72760.,  70300.,  71480.,  72660.,  73840.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      944.,  1004., 1064., 1124., 1010., 1076., 1142., 1208., 1076., 1148.,
      1220., 1292., 1142., 1220., 1298., 1376., 1208., 1292., 1376., 1460.,
      1274., 1364., 1454., 1544., 1340., 1436., 1532., 1628., 1406., 1508.,
      1610., 1712., 1472., 1580., 1688., 1796., 1538., 1652., 1766., 1880.,
      1868., 2012., 2156., 2300., 1934., 2084., 2234., 2384., 2000., 2156.,
      2312., 2468., 2066., 2228., 2390., 2552., 2132., 2300., 2468., 2636.,
      2198., 2372., 2546., 2720., 2264., 2444., 2624., 2804., 2330., 2516.,
      2702., 2888., 2396., 2588., 2780., 2972., 2462., 2660., 2858., 3056.,
      2792., 3020., 3248., 3476., 2858., 3092., 3326., 3560., 2924., 3164.,
      3404., 3644., 2990., 3236., 3482., 3728., 3056., 3308., 3560., 3812.,
      3122., 3380., 3638., 3896., 3188., 3452., 3716., 3980., 3254., 3524.,
      3794., 4064., 3320., 3596., 3872., 4148., 3386., 3668., 3950., 4232.,
      3716., 4028., 4340., 4652., 3782., 4100., 4418., 4736., 3848., 4172.,
      4496., 4820., 3914., 4244., 4574., 4904., 3980., 4316., 4652., 4988.,
      4046., 4388., 4730., 5072., 4112., 4460., 4808., 5156., 4178., 4532.,
      4886., 5240., 4244., 4604., 4964., 5324., 4310., 4676., 5042., 5408.,
      4640., 5036., 5432., 5828., 4706., 5108., 5510., 5912., 4772., 5180.,
      5588., 5996., 4838., 5252., 5666., 6080., 4904., 5324., 5744., 6164.,
      4970., 5396., 5822., 6248., 5036., 5468., 5900., 6332., 5102., 5540.,
      5978., 6416., 5168., 5612., 6056., 6500., 5234., 5684., 6134., 6584.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      35150., 35740., 36330., 36920., 43048.,  43744.,  44440.,  45136., 51198.,
      51996., 52794., 53592., 44464., 45136.,  45808.,  46480.,  37510., 38060.,
      38610., 39160., 52250., 52900., 53550.,  54200.,  63365.,  64130., 64895.,
      65660., 74655., 75530., 76405., 77280.,  64295.,  65030.,  65765., 66500.,
      53800., 54400., 55000., 55600., 70715.,  71390.,  72065.,  72740., 85152.,
      85944., 86736., 87528., 99631., 100534., 101437., 102340., 85260., 86016.,
      86772., 87528., 70895., 71510., 72125.,  72740.,  54175.,  54650., 55125.,
      55600., 64835., 65390., 65945., 66500.,  75390.,  76020.,  76650., 77280.,
      64085., 64610., 65135., 65660., 52925.,  53350.,  53775.,  54200., 38230.,
      38540., 38850., 39160., 45400., 45760.,  46120.,  46480.,  52374., 52780.,
      53186., 53592., 44128., 44464., 44800.,  45136.,  36110.,  36380., 36650.,
      36920.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      541.,  562.,  583.,  604.,  625.,  646.,  667.,  688.,  709.,  730.,
      751.,  772.,  793.,  814.,  835.,  856.,  877.,  898.,  919.,  940.,
      1129., 1150., 1171., 1192., 1213., 1234., 1255., 1276., 1297., 1318.,
      1339., 1360., 1381., 1402., 1423., 1444., 1465., 1486., 1507., 1528.,
      1717., 1738., 1759., 1780., 1801., 1822., 1843., 1864., 1885., 1906.,
      1927., 1948., 1969., 1990., 2011., 2032., 2053., 2074., 2095., 2116.,
      2305., 2326., 2347., 2368., 2389., 2410., 2431., 2452., 2473., 2494.,
      2515., 2536., 2557., 2578., 2599., 2620., 2641., 2662., 2683., 2704.,
      2893., 2914., 2935., 2956., 2977., 2998., 3019., 3040., 3061., 3082.,
      3103., 3124., 3145., 3166., 3187., 3208., 3229., 3250., 3271., 3292.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      69280.,  70300.,  70440.,  71480.,  71600.,  72660.,  72760.,  73840.,
      84824.,  86096.,  86192.,  87488.,  87560.,  88880.,  88928.,  90272.,
      100856., 102396., 102424., 103992., 103992., 105588., 105560., 107184.,
      87560.,  88928.,  88880.,  90272.,  90200.,  91616.,  91520.,  92960.,
      73840.,  75020.,  74920.,  76120.,  76000.,  77220.,  77080.,  78320.,
      102875., 104500., 104150., 105800., 105425., 107100., 106700., 108400.,
      124720., 126730., 126220., 128260., 127720., 129790., 129220., 131320.,
      146895., 149310., 148610., 151060., 150325., 152810., 152040., 154560.,
      126460., 128590., 127900., 130060., 129340., 131530., 130780., 133000.,
      105775., 107600., 106950., 108800., 108125., 110000., 109300., 111200.,
      139060., 141430., 140380., 142780., 141700., 144130., 143020., 145480.,
      167388., 170304., 168936., 171888., 170484., 173472., 172032., 175056.,
      195776., 199262., 197540., 201068., 199304., 202874., 201068., 204680.,
      167460., 170520., 168936., 172032., 170412., 173544., 171888., 175056.,
      139180., 141790., 140380., 143020., 141580., 144250., 142780., 145480.,
      106025., 108350., 106950., 109300., 107875., 110250., 108800., 111200.,
      126820., 129670., 127900., 130780., 128980., 131890., 130060., 133000.,
      147385., 150780., 148610., 152040., 149835., 153300., 151060., 154560.,
      125200., 128170., 126220., 129220., 127240., 130270., 128260., 131320.,
      103325., 105850., 104150., 106700., 104975., 107550., 105800., 108400.,
      74320.,  76460.,  74920.,  77080.,  75520.,  77700.,  76120.,  78320.,
      88184.,  90800.,  88880.,  91520.,  89576.,  92240.,  90272.,  92960.,
      101640., 104748., 102424., 105560., 103208., 106372., 103992., 107184.,
      85544.,  88256.,  86192.,  88928.,  86840.,  89600.,  87488.,  90272.,
      69920.,  72220.,  70440.,  72760.,  70960.,  73300.,  71480.,  73840.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      968.,  1082., 1004., 1124., 1040., 1166., 1076., 1208., 1112., 1250.,
      1148., 1292., 1184., 1334., 1220., 1376., 1256., 1418., 1292., 1460.,
      1328., 1502., 1364., 1544., 1400., 1586., 1436., 1628., 1472., 1670.,
      1508., 1712., 1544., 1754., 1580., 1796., 1616., 1838., 1652., 1880.,
      1976., 2258., 2012., 2300., 2048., 2342., 2084., 2384., 2120., 2426.,
      2156., 2468., 2192., 2510., 2228., 2552., 2264., 2594., 2300., 2636.,
      2336., 2678., 2372., 2720., 2408., 2762., 2444., 2804., 2480., 2846.,
      2516., 2888., 2552., 2930., 2588., 2972., 2624., 3014., 2660., 3056.,
      2984., 3434., 3020., 3476., 3056., 3518., 3092., 3560., 3128., 3602.,
      3164., 3644., 3200., 3686., 3236., 3728., 3272., 3770., 3308., 3812.,
      3344., 3854., 3380., 3896., 3416., 3938., 3452., 3980., 3488., 4022.,
      3524., 4064., 3560., 4106., 3596., 4148., 3632., 4190., 3668., 4232.,
      3992., 4610., 4028., 4652., 4064., 4694., 4100., 4736., 4136., 4778.,
      4172., 4820., 4208., 4862., 4244., 4904., 4280., 4946., 4316., 4988.,
      4352., 5030., 4388., 5072., 4424., 5114., 4460., 5156., 4496., 5198.,
      4532., 5240., 4568., 5282., 4604., 5324., 4640., 5366., 4676., 5408.,
      5000., 5786., 5036., 5828., 5072., 5870., 5108., 5912., 5144., 5954.,
      5180., 5996., 5216., 6038., 5252., 6080., 5288., 6122., 5324., 6164.,
      5360., 6206., 5396., 6248., 5432., 6290., 5468., 6332., 5504., 6374.,
      5540., 6416., 5576., 6458., 5612., 6500., 5648., 6542., 5684., 6584.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      137540., 138560., 139580., 140600., 139840., 140880., 141920., 142960.,
      142140., 143200., 144260., 145320., 144440., 145520., 146600., 147680.,
      168376., 169648., 170920., 172192., 171088., 172384., 173680., 174976.,
      173800., 175120., 176440., 177760., 176512., 177856., 179200., 180544.,
      200172., 201712., 203252., 204792., 203280., 204848., 206416., 207984.,
      206388., 207984., 209580., 211176., 209496., 211120., 212744., 214368.,
      173752., 175120., 176488., 177856., 176368., 177760., 179152., 180544.,
      178984., 180400., 181816., 183232., 181600., 183040., 184480., 185920.,
      146500., 147680., 148860., 150040., 148640., 149840., 151040., 152240.,
      150780., 152000., 153220., 154440., 152920., 154160., 155400., 156640.,
      204125., 205750., 207375., 209000., 206650., 208300., 209950., 211600.,
      209175., 210850., 212525., 214200., 211700., 213400., 215100., 216800.,
      247430., 249440., 251450., 253460., 250400., 252440., 254480., 256520.,
      253370., 255440., 257510., 259580., 256340., 258440., 260540., 262640.,
      291375., 293790., 296205., 298620., 294770., 297220., 299670., 302120.,
      298165., 300650., 303135., 305620., 301560., 304080., 306600., 309120.,
      250790., 252920., 255050., 257180., 253640., 255800., 257960., 260120.,
      256490., 258680., 260870., 263060., 259340., 261560., 263780., 266000.,
      209725., 211550., 213375., 215200., 212050., 213900., 215750., 217600.,
      214375., 216250., 218125., 220000., 216700., 218600., 220500., 222400.,
      275750., 278120., 280490., 282860., 278360., 280760., 283160., 285560.,
      280970., 283400., 285830., 288260., 283580., 286040., 288500., 290960.,
      331860., 334776., 337692., 340608., 334920., 337872., 340824., 343776.,
      337980., 340968., 343956., 346944., 341040., 344064., 347088., 350112.,
      388066., 391552., 395038., 398524., 391552., 395080., 398608., 402136.,
      395038., 398608., 402178., 405748., 398524., 402136., 405748., 409360.,
      331860., 334920., 337980., 341040., 334776., 337872., 340968., 344064.,
      337692., 340824., 343956., 347088., 340608., 343776., 346944., 350112.,
      275750., 278360., 280970., 283580., 278120., 280760., 283400., 286040.,
      280490., 283160., 285830., 288500., 282860., 285560., 288260., 290960.,
      209725., 212050., 214375., 216700., 211550., 213900., 216250., 218600.,
      213375., 215750., 218125., 220500., 215200., 217600., 220000., 222400.,
      250790., 253640., 256490., 259340., 252920., 255800., 258680., 261560.,
      255050., 257960., 260870., 263780., 257180., 260120., 263060., 266000.,
      291375., 294770., 298165., 301560., 293790., 297220., 300650., 304080.,
      296205., 299670., 303135., 306600., 298620., 302120., 305620., 309120.,
      247430., 250400., 253370., 256340., 249440., 252440., 255440., 258440.,
      251450., 254480., 257510., 260540., 253460., 256520., 259580., 262640.,
      204125., 206650., 209175., 211700., 205750., 208300., 210850., 213400.,
      207375., 209950., 212525., 215100., 209000., 211600., 214200., 216800.,
      146500., 148640., 150780., 152920., 147680., 149840., 152000., 154160.,
      148860., 151040., 153220., 155400., 150040., 152240., 154440., 156640.,
      173752., 176368., 178984., 181600., 175120., 177760., 180400., 183040.,
      176488., 179152., 181816., 184480., 177856., 180544., 183232., 185920.,
      200172., 203280., 206388., 209496., 201712., 204848., 207984., 211120.,
      203252., 206416., 209580., 212744., 204792., 207984., 211176., 214368.,
      168376., 171088., 173800., 176512., 169648., 172384., 175120., 177856.,
      170920., 173680., 176440., 179200., 172192., 174976., 177760., 180544.,
      137540., 139840., 142140., 144440., 138560., 140880., 143200., 145520.,
      139580., 141920., 144260., 146600., 140600., 142960., 145320., 147680.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1822.,  1936.,  2050.,  2164.,  1888.,  2008.,  2128.,  2248.,  1954.,
      2080.,  2206.,  2332.,  2020.,  2152.,  2284.,  2416.,  2086.,  2224.,
      2362.,  2500.,  2152.,  2296.,  2440.,  2584.,  2218.,  2368.,  2518.,
      2668.,  2284.,  2440.,  2596.,  2752.,  2350.,  2512.,  2674.,  2836.,
      2416.,  2584.,  2752.,  2920.,  2482.,  2656.,  2830.,  3004.,  2548.,
      2728.,  2908.,  3088.,  2614.,  2800.,  2986.,  3172.,  2680.,  2872.,
      3064.,  3256.,  2746.,  2944.,  3142.,  3340.,  2812.,  3016.,  3220.,
      3424.,  2878.,  3088.,  3298.,  3508.,  2944.,  3160.,  3376.,  3592.,
      3010.,  3232.,  3454.,  3676.,  3076.,  3304.,  3532.,  3760.,  3670.,
      3952.,  4234.,  4516.,  3736.,  4024.,  4312.,  4600.,  3802.,  4096.,
      4390.,  4684.,  3868.,  4168.,  4468.,  4768.,  3934.,  4240.,  4546.,
      4852.,  4000.,  4312.,  4624.,  4936.,  4066.,  4384.,  4702.,  5020.,
      4132.,  4456.,  4780.,  5104.,  4198.,  4528.,  4858.,  5188.,  4264.,
      4600.,  4936.,  5272.,  4330.,  4672.,  5014.,  5356.,  4396.,  4744.,
      5092.,  5440.,  4462.,  4816.,  5170.,  5524.,  4528.,  4888.,  5248.,
      5608.,  4594.,  4960.,  5326.,  5692.,  4660.,  5032.,  5404.,  5776.,
      4726.,  5104.,  5482.,  5860.,  4792.,  5176.,  5560.,  5944.,  4858.,
      5248.,  5638.,  6028.,  4924.,  5320.,  5716.,  6112.,  5518.,  5968.,
      6418.,  6868.,  5584.,  6040.,  6496.,  6952.,  5650.,  6112.,  6574.,
      7036.,  5716.,  6184.,  6652.,  7120.,  5782.,  6256.,  6730.,  7204.,
      5848.,  6328.,  6808.,  7288.,  5914.,  6400.,  6886.,  7372.,  5980.,
      6472.,  6964.,  7456.,  6046.,  6544.,  7042.,  7540.,  6112.,  6616.,
      7120.,  7624.,  6178.,  6688.,  7198.,  7708.,  6244.,  6760.,  7276.,
      7792.,  6310.,  6832.,  7354.,  7876.,  6376.,  6904.,  7432.,  7960.,
      6442.,  6976.,  7510.,  8044.,  6508.,  7048.,  7588.,  8128.,  6574.,
      7120.,  7666.,  8212.,  6640.,  7192.,  7744.,  8296.,  6706.,  7264.,
      7822.,  8380.,  6772.,  7336.,  7900.,  8464.,  7366.,  7984.,  8602.,
      9220.,  7432.,  8056.,  8680.,  9304.,  7498.,  8128.,  8758.,  9388.,
      7564.,  8200.,  8836.,  9472.,  7630.,  8272.,  8914.,  9556.,  7696.,
      8344.,  8992.,  9640.,  7762.,  8416.,  9070.,  9724.,  7828.,  8488.,
      9148.,  9808.,  7894.,  8560.,  9226.,  9892.,  7960.,  8632.,  9304.,
      9976.,  8026.,  8704.,  9382.,  10060., 8092.,  8776.,  9460.,  10144.,
      8158.,  8848.,  9538.,  10228., 8224.,  8920.,  9616.,  10312., 8290.,
      8992.,  9694.,  10396., 8356.,  9064.,  9772.,  10480., 8422.,  9136.,
      9850.,  10564., 8488.,  9208.,  9928.,  10648., 8554.,  9280.,  10006.,
      10732., 8620.,  9352.,  10084., 10816., 9214.,  10000., 10786., 11572.,
      9280.,  10072., 10864., 11656., 9346.,  10144., 10942., 11740., 9412.,
      10216., 11020., 11824., 9478.,  10288., 11098., 11908., 9544.,  10360.,
      11176., 11992., 9610.,  10432., 11254., 12076., 9676.,  10504., 11332.,
      12160., 9742.,  10576., 11410., 12244., 9808.,  10648., 11488., 12328.,
      9874.,  10720., 11566., 12412., 9940.,  10792., 11644., 12496., 10006.,
      10864., 11722., 12580., 10072., 10936., 11800., 12664., 10138., 11008.,
      11878., 12748., 10204., 11080., 11956., 12832., 10270., 11152., 12034.,
      12916., 10336., 11224., 12112., 13000., 10402., 11296., 12190., 13084.,
      10468., 11368., 12268., 13168.};
  const std::array<int, 4> in_shape = {{1, 6, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14452., 17136., 19888., 17584., 15220., 21185., 24920., 28700., 25200.,
      21665., 28398., 33208., 38024., 33208., 28398., 21665., 25200., 28700.,
      24920., 21185., 15220., 17584., 19888., 17136., 14452.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      308.,  344.,  380.,  416.,  452.,  596.,  632.,  668.,  704.,
      740.,  884.,  920.,  956.,  992.,  1028., 1172., 1208., 1244.,
      1280., 1316., 1460., 1496., 1532., 1568., 1604.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28532., 28904., 33824., 34272., 39248., 39776., 34692., 35168., 30020.,
      30440., 41785., 42370., 49140., 49840., 56580., 57400., 49665., 50400.,
      42685., 43330., 55950., 56796., 65408., 66416., 74872., 76048., 65366.,
      66416., 55878., 56796., 42505., 43330., 49420., 50400., 56260., 57400.,
      48825., 49840., 41485., 42370., 29684., 30440., 34272., 35168., 38736.,
      39776., 33348., 34272., 28100., 28904.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      564.,  616.,  628.,  688.,  692.,  760.,  756.,  832.,  820.,  904.,
      1076., 1192., 1140., 1264., 1204., 1336., 1268., 1408., 1332., 1480.,
      1588., 1768., 1652., 1840., 1716., 1912., 1780., 1984., 1844., 2056.,
      2100., 2344., 2164., 2416., 2228., 2488., 2292., 2560., 2356., 2632.,
      2612., 2920., 2676., 2992., 2740., 3064., 2804., 3136., 2868., 3208.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      56692.,  57064.,  57436.,  57808.,  67200.,  67648.,  68096.,  68544.,
      77968.,  78496.,  79024.,  79552.,  68908.,  69384.,  69860.,  70336.,
      59620.,  60040.,  60460.,  60880.,  82985.,  83570.,  84155.,  84740.,
      97580.,  98280.,  98980.,  99680.,  112340., 113160., 113980., 114800.,
      98595.,  99330.,  100065., 100800., 84725.,  85370.,  86015.,  86660.,
      111054., 111900., 112746., 113592., 129808., 130816., 131824., 132832.,
      148568., 149744., 150920., 152096., 129682., 130732., 131782., 132832.,
      110838., 111756., 112674., 113592., 84185.,  85010.,  85835.,  86660.,
      97860.,  98840.,  99820.,  100800., 111380., 112520., 113660., 114800.,
      96635.,  97650.,  98665.,  99680.,  82085.,  82970.,  83855.,  84740.,
      58612.,  59368.,  60124.,  60880.,  67648.,  68544.,  69440.,  70336.,
      76432.,  77472.,  78512.,  79552.,  65772.,  66696.,  67620.,  68544.,
      55396.,  56200.,  57004.,  57808.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1076., 1128., 1180., 1232., 1196., 1256., 1316., 1376., 1316., 1384.,
      1452., 1520., 1436., 1512., 1588., 1664., 1556., 1640., 1724., 1808.,
      2036., 2152., 2268., 2384., 2156., 2280., 2404., 2528., 2276., 2408.,
      2540., 2672., 2396., 2536., 2676., 2816., 2516., 2664., 2812., 2960.,
      2996., 3176., 3356., 3536., 3116., 3304., 3492., 3680., 3236., 3432.,
      3628., 3824., 3356., 3560., 3764., 3968., 3476., 3688., 3900., 4112.,
      3956., 4200., 4444., 4688., 4076., 4328., 4580., 4832., 4196., 4456.,
      4716., 4976., 4316., 4584., 4852., 5120., 4436., 4712., 4988., 5264.,
      4916., 5224., 5532., 5840., 5036., 5352., 5668., 5984., 5156., 5480.,
      5804., 6128., 5276., 5608., 5940., 6272., 5396., 5736., 6076., 6416.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28100., 28904., 33348., 34272., 38736., 39776., 34272., 35168., 29684.,
      30440., 41485., 42370., 48825., 49840., 56260., 57400., 49420., 50400.,
      42505., 43330., 55878., 56796., 65366., 66416., 74872., 76048., 65408.,
      66416., 55950., 56796., 42685., 43330., 49665., 50400., 56580., 57400.,
      49140., 49840., 41785., 42370., 30020., 30440., 34692., 35168., 39248.,
      39776., 33824., 34272., 28532., 28904.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      580.,  616.,  652.,  688.,  724.,  760.,  796.,  832.,  868.,  904.,
      1156., 1192., 1228., 1264., 1300., 1336., 1372., 1408., 1444., 1480.,
      1732., 1768., 1804., 1840., 1876., 1912., 1948., 1984., 2020., 2056.,
      2308., 2344., 2380., 2416., 2452., 2488., 2524., 2560., 2596., 2632.,
      2884., 2920., 2956., 2992., 3028., 3064., 3100., 3136., 3172., 3208.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55480.,  56200.,  57064.,  57808.,  65828.,  66696.,  67648.,  68544.,
      76448.,  77472.,  78496.,  79552.,  67620.,  68544.,  69384.,  70336.,
      58552.,  59368.,  60040.,  60880.,  81830.,  82970.,  83570.,  84740.,
      96285.,  97650.,  98280.,  99680.,  110920., 112520., 113160., 114800.,
      97405.,  98840.,  99330.,  100800., 83750.,  85010.,  85370.,  86660.,
      110100., 111756., 111900., 113592., 128758., 130732., 130816., 132832.,
      147440., 149744., 149744., 152096., 128758., 130816., 130732., 132832.,
      110100., 111900., 111756., 113592., 83750.,  85370.,  85010.,  86660.,
      97405.,  99330.,  98840.,  100800., 110920., 113160., 112520., 114800.,
      96285.,  98280.,  97650.,  99680.,  81830.,  83570.,  82970.,  84740.,
      58552.,  60040.,  59368.,  60880.,  67620.,  69384.,  68544.,  70336.,
      76448.,  78496.,  77472.,  79552.,  65828.,  67648.,  66696.,  68544.,
      55480.,  57064.,  56200.,  57808.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1064., 1160., 1128., 1232., 1192., 1304., 1256., 1376., 1320., 1448.,
      1384., 1520., 1448., 1592., 1512., 1664., 1576., 1736., 1640., 1808.,
      2088., 2312., 2152., 2384., 2216., 2456., 2280., 2528., 2344., 2600.,
      2408., 2672., 2472., 2744., 2536., 2816., 2600., 2888., 2664., 2960.,
      3112., 3464., 3176., 3536., 3240., 3608., 3304., 3680., 3368., 3752.,
      3432., 3824., 3496., 3896., 3560., 3968., 3624., 4040., 3688., 4112.,
      4136., 4616., 4200., 4688., 4264., 4760., 4328., 4832., 4392., 4904.,
      4456., 4976., 4520., 5048., 4584., 5120., 4648., 5192., 4712., 5264.,
      5160., 5768., 5224., 5840., 5288., 5912., 5352., 5984., 5416., 6056.,
      5480., 6128., 5544., 6200., 5608., 6272., 5672., 6344., 5736., 6416.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      110240., 110960., 111680., 112400., 113384., 114128., 114872., 115616.,
      130788., 131656., 132524., 133392., 134400., 135296., 136192., 137088.,
      151872., 152896., 153920., 154944., 155936., 156992., 158048., 159104.,
      134316., 135240., 136164., 137088., 137816., 138768., 139720., 140672.,
      116288., 117104., 117920., 118736., 119240., 120080., 120920., 121760.,
      162520., 163660., 164800., 165940., 165970., 167140., 168310., 169480.,
      191205., 192570., 193935., 195300., 195160., 196560., 197960., 199360.,
      220240., 221840., 223440., 225040., 224680., 226320., 227960., 229600.,
      193375., 194810., 196245., 197680., 197190., 198660., 200130., 201600.,
      166240., 167500., 168760., 170020., 169450., 170740., 172030., 173320.,
      218544., 220200., 221856., 223512., 222108., 223800., 225492., 227184.,
      255542., 257516., 259490., 261464., 259616., 261632., 263648., 265664.,
      292576., 294880., 297184., 299488., 297136., 299488., 301840., 304192.,
      255458., 257516., 259574., 261632., 259364., 261464., 263564., 265664.,
      218400., 220200., 222000., 223800., 221676., 223512., 225348., 227184.,
      165880., 167500., 169120., 170740., 168370., 170020., 171670., 173320.,
      192885., 194810., 196735., 198660., 195720., 197680., 199640., 201600.,
      219600., 221840., 224080., 226320., 222760., 225040., 227320., 229600.,
      190575., 192570., 194565., 196560., 193270., 195300., 197330., 199360.,
      161920., 163660., 165400., 167140., 164170., 165940., 167710., 169480.,
      115616., 117104., 118592., 120080., 117224., 118736., 120248., 121760.,
      133476., 135240., 137004., 138768., 135296., 137088., 138880., 140672.,
      150848., 152896., 154944., 156992., 152864., 154944., 157024., 159104.,
      129836., 131656., 133476., 135296., 131544., 133392., 135240., 137088.,
      109376., 110960., 112544., 114128., 110792., 112400., 114008., 115616.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2032.,  2128.,  2224.,  2320.,  2152.,  2256.,  2360.,  2464.,  2272.,
      2384.,  2496.,  2608.,  2392.,  2512.,  2632.,  2752.,  2512.,  2640.,
      2768.,  2896.,  2632.,  2768.,  2904.,  3040.,  2752.,  2896.,  3040.,
      3184.,  2872.,  3024.,  3176.,  3328.,  2992.,  3152.,  3312.,  3472.,
      3112.,  3280.,  3448.,  3616.,  3952.,  4176.,  4400.,  4624.,  4072.,
      4304.,  4536.,  4768.,  4192.,  4432.,  4672.,  4912.,  4312.,  4560.,
      4808.,  5056.,  4432.,  4688.,  4944.,  5200.,  4552.,  4816.,  5080.,
      5344.,  4672.,  4944.,  5216.,  5488.,  4792.,  5072.,  5352.,  5632.,
      4912.,  5200.,  5488.,  5776.,  5032.,  5328.,  5624.,  5920.,  5872.,
      6224.,  6576.,  6928.,  5992.,  6352.,  6712.,  7072.,  6112.,  6480.,
      6848.,  7216.,  6232.,  6608.,  6984.,  7360.,  6352.,  6736.,  7120.,
      7504.,  6472.,  6864.,  7256.,  7648.,  6592.,  6992.,  7392.,  7792.,
      6712.,  7120.,  7528.,  7936.,  6832.,  7248.,  7664.,  8080.,  6952.,
      7376.,  7800.,  8224.,  7792.,  8272.,  8752.,  9232.,  7912.,  8400.,
      8888.,  9376.,  8032.,  8528.,  9024.,  9520.,  8152.,  8656.,  9160.,
      9664.,  8272.,  8784.,  9296.,  9808.,  8392.,  8912.,  9432.,  9952.,
      8512.,  9040.,  9568.,  10096., 8632.,  9168.,  9704.,  10240., 8752.,
      9296.,  9840.,  10384., 8872.,  9424.,  9976.,  10528., 9712.,  10320.,
      10928., 11536., 9832.,  10448., 11064., 11680., 9952.,  10576., 11200.,
      11824., 10072., 10704., 11336., 11968., 10192., 10832., 11472., 12112.,
      10312., 10960., 11608., 12256., 10432., 11088., 11744., 12400., 10552.,
      11216., 11880., 12544., 10672., 11344., 12016., 12688., 10792., 11472.,
      12152., 12832.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55396.,  56200.,  57004.,  57808.,  65772.,  66696.,  67620.,  68544.,
      76432.,  77472.,  78512.,  79552.,  67648.,  68544.,  69440.,  70336.,
      58612.,  59368.,  60124.,  60880.,  82085.,  82970.,  83855.,  84740.,
      96635.,  97650.,  98665.,  99680.,  111380., 112520., 113660., 114800.,
      97860.,  98840.,  99820.,  100800., 84185.,  85010.,  85835.,  86660.,
      110838., 111756., 112674., 113592., 129682., 130732., 131782., 132832.,
      148568., 149744., 150920., 152096., 129808., 130816., 131824., 132832.,
      111054., 111900., 112746., 113592., 84725.,  85370.,  86015.,  86660.,
      98595.,  99330.,  100065., 100800., 112340., 113160., 113980., 114800.,
      97580.,  98280.,  98980.,  99680.,  82985.,  83570.,  84155.,  84740.,
      59620.,  60040.,  60460.,  60880.,  68908.,  69384.,  69860.,  70336.,
      77968.,  78496.,  79024.,  79552.,  67200.,  67648.,  68096.,  68544.,
      56692.,  57064.,  57436.,  57808.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1124., 1160., 1196., 1232., 1268., 1304., 1340., 1376., 1412., 1448.,
      1484., 1520., 1556., 1592., 1628., 1664., 1700., 1736., 1772., 1808.,
      2276., 2312., 2348., 2384., 2420., 2456., 2492., 2528., 2564., 2600.,
      2636., 2672., 2708., 2744., 2780., 2816., 2852., 2888., 2924., 2960.,
      3428., 3464., 3500., 3536., 3572., 3608., 3644., 3680., 3716., 3752.,
      3788., 3824., 3860., 3896., 3932., 3968., 4004., 4040., 4076., 4112.,
      4580., 4616., 4652., 4688., 4724., 4760., 4796., 4832., 4868., 4904.,
      4940., 4976., 5012., 5048., 5084., 5120., 5156., 5192., 5228., 5264.,
      5732., 5768., 5804., 5840., 5876., 5912., 5948., 5984., 6020., 6056.,
      6092., 6128., 6164., 6200., 6236., 6272., 6308., 6344., 6380., 6416.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109376., 110792., 110960., 112400., 112544., 114008., 114128., 115616.,
      129836., 131544., 131656., 133392., 133476., 135240., 135296., 137088.,
      150848., 152864., 152896., 154944., 154944., 157024., 156992., 159104.,
      133476., 135296., 135240., 137088., 137004., 138880., 138768., 140672.,
      115616., 117224., 117104., 118736., 118592., 120248., 120080., 121760.,
      161920., 164170., 163660., 165940., 165400., 167710., 167140., 169480.,
      190575., 193270., 192570., 195300., 194565., 197330., 196560., 199360.,
      219600., 222760., 221840., 225040., 224080., 227320., 226320., 229600.,
      192885., 195720., 194810., 197680., 196735., 199640., 198660., 201600.,
      165880., 168370., 167500., 170020., 169120., 171670., 170740., 173320.,
      218400., 221676., 220200., 223512., 222000., 225348., 223800., 227184.,
      255458., 259364., 257516., 261464., 259574., 263564., 261632., 265664.,
      292576., 297136., 294880., 299488., 297184., 301840., 299488., 304192.,
      255542., 259616., 257516., 261632., 259490., 263648., 261464., 265664.,
      218544., 222108., 220200., 223800., 221856., 225492., 223512., 227184.,
      166240., 169450., 167500., 170740., 168760., 172030., 170020., 173320.,
      193375., 197190., 194810., 198660., 196245., 200130., 197680., 201600.,
      220240., 224680., 221840., 226320., 223440., 227960., 225040., 229600.,
      191205., 195160., 192570., 196560., 193935., 197960., 195300., 199360.,
      162520., 165970., 163660., 167140., 164800., 168310., 165940., 169480.,
      116288., 119240., 117104., 120080., 117920., 120920., 118736., 121760.,
      134316., 137816., 135240., 138768., 136164., 139720., 137088., 140672.,
      151872., 155936., 152896., 156992., 153920., 158048., 154944., 159104.,
      130788., 134400., 131656., 135296., 132524., 136192., 133392., 137088.,
      110240., 113384., 110960., 114128., 111680., 114872., 112400., 115616.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2064.,  2248.,  2128.,  2320.,  2192.,  2392.,  2256.,  2464.,  2320.,
      2536.,  2384.,  2608.,  2448.,  2680.,  2512.,  2752.,  2576.,  2824.,
      2640.,  2896.,  2704.,  2968.,  2768.,  3040.,  2832.,  3112.,  2896.,
      3184.,  2960.,  3256.,  3024.,  3328.,  3088.,  3400.,  3152.,  3472.,
      3216.,  3544.,  3280.,  3616.,  4112.,  4552.,  4176.,  4624.,  4240.,
      4696.,  4304.,  4768.,  4368.,  4840.,  4432.,  4912.,  4496.,  4984.,
      4560.,  5056.,  4624.,  5128.,  4688.,  5200.,  4752.,  5272.,  4816.,
      5344.,  4880.,  5416.,  4944.,  5488.,  5008.,  5560.,  5072.,  5632.,
      5136.,  5704.,  5200.,  5776.,  5264.,  5848.,  5328.,  5920.,  6160.,
      6856.,  6224.,  6928.,  6288.,  7000.,  6352.,  7072.,  6416.,  7144.,
      6480.,  7216.,  6544.,  7288.,  6608.,  7360.,  6672.,  7432.,  6736.,
      7504.,  6800.,  7576.,  6864.,  7648.,  6928.,  7720.,  6992.,  7792.,
      7056.,  7864.,  7120.,  7936.,  7184.,  8008.,  7248.,  8080.,  7312.,
      8152.,  7376.,  8224.,  8208.,  9160.,  8272.,  9232.,  8336.,  9304.,
      8400.,  9376.,  8464.,  9448.,  8528.,  9520.,  8592.,  9592.,  8656.,
      9664.,  8720.,  9736.,  8784.,  9808.,  8848.,  9880.,  8912.,  9952.,
      8976.,  10024., 9040.,  10096., 9104.,  10168., 9168.,  10240., 9232.,
      10312., 9296.,  10384., 9360.,  10456., 9424.,  10528., 10256., 11464.,
      10320., 11536., 10384., 11608., 10448., 11680., 10512., 11752., 10576.,
      11824., 10640., 11896., 10704., 11968., 10768., 12040., 10832., 12112.,
      10896., 12184., 10960., 12256., 11024., 12328., 11088., 12400., 11152.,
      12472., 11216., 12544., 11280., 12616., 11344., 12688., 11408., 12760.,
      11472., 12832.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      217336., 218752., 220168., 221584., 220480., 221920., 223360., 224800.,
      223624., 225088., 226552., 228016., 226768., 228256., 229744., 231232.,
      257964., 259672., 261380., 263088., 261576., 263312., 265048., 266784.,
      265188., 266952., 268716., 270480., 268800., 270592., 272384., 274176.,
      299680., 301696., 303712., 305728., 303744., 305792., 307840., 309888.,
      307808., 309888., 311968., 314048., 311872., 313984., 316096., 318208.,
      265132., 266952., 268772., 270592., 268632., 270480., 272328., 274176.,
      272132., 274008., 275884., 277760., 275632., 277536., 279440., 281344.,
      229624., 231232., 232840., 234448., 232576., 234208., 235840., 237472.,
      235528., 237184., 238840., 240496., 238480., 240160., 241840., 243520.,
      321590., 323840., 326090., 328340., 325040., 327320., 329600., 331880.,
      328490., 330800., 333110., 335420., 331940., 334280., 336620., 338960.,
      378455., 381150., 383845., 386540., 382410., 385140., 387870., 390600.,
      386365., 389130., 391895., 394660., 390320., 393120., 395920., 398720.,
      436040., 439200., 442360., 445520., 440480., 443680., 446880., 450080.,
      444920., 448160., 451400., 454640., 449360., 452640., 455920., 459200.,
      382935., 385770., 388605., 391440., 386750., 389620., 392490., 395360.,
      390565., 393470., 396375., 399280., 394380., 397320., 400260., 403200.,
      329270., 331760., 334250., 336740., 332480., 335000., 337520., 340040.,
      335690., 338240., 340790., 343340., 338900., 341480., 344060., 346640.,
      433524., 436800., 440076., 443352., 437088., 440400., 443712., 447024.,
      440652., 444000., 447348., 450696., 444216., 447600., 450984., 454368.,
      507010., 510916., 514822., 518728., 511084., 515032., 518980., 522928.,
      515158., 519148., 523138., 527128., 519232., 523264., 527296., 531328.,
      580592., 585152., 589712., 594272., 585152., 589760., 594368., 598976.,
      589712., 594368., 599024., 603680., 594272., 598976., 603680., 608384.,
      507010., 511084., 515158., 519232., 510916., 515032., 519148., 523264.,
      514822., 518980., 523138., 527296., 518728., 522928., 527128., 531328.,
      433524., 437088., 440652., 444216., 436800., 440400., 444000., 447600.,
      440076., 443712., 447348., 450984., 443352., 447024., 450696., 454368.,
      329270., 332480., 335690., 338900., 331760., 335000., 338240., 341480.,
      334250., 337520., 340790., 344060., 336740., 340040., 343340., 346640.,
      382935., 386750., 390565., 394380., 385770., 389620., 393470., 397320.,
      388605., 392490., 396375., 400260., 391440., 395360., 399280., 403200.,
      436040., 440480., 444920., 449360., 439200., 443680., 448160., 452640.,
      442360., 446880., 451400., 455920., 445520., 450080., 454640., 459200.,
      378455., 382410., 386365., 390320., 381150., 385140., 389130., 393120.,
      383845., 387870., 391895., 395920., 386540., 390600., 394660., 398720.,
      321590., 325040., 328490., 331940., 323840., 327320., 330800., 334280.,
      326090., 329600., 333110., 336620., 328340., 331880., 335420., 338960.,
      229624., 232576., 235528., 238480., 231232., 234208., 237184., 240160.,
      232840., 235840., 238840., 241840., 234448., 237472., 240496., 243520.,
      265132., 268632., 272132., 275632., 266952., 270480., 274008., 277536.,
      268772., 272328., 275884., 279440., 270592., 274176., 277760., 281344.,
      299680., 303744., 307808., 311872., 301696., 305792., 309888., 313984.,
      303712., 307840., 311968., 316096., 305728., 309888., 314048., 318208.,
      257964., 261576., 265188., 268800., 259672., 263312., 266952., 270592.,
      261380., 265048., 268716., 272384., 263088., 266784., 270480., 274176.,
      217336., 220480., 223624., 226768., 218752., 221920., 225088., 228256.,
      220168., 223360., 226552., 229744., 221584., 224800., 228016., 231232.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3944.,  4128.,  4312.,  4496.,  4064.,  4256.,  4448.,  4640.,  4184.,
      4384.,  4584.,  4784.,  4304.,  4512.,  4720.,  4928.,  4424.,  4640.,
      4856.,  5072.,  4544.,  4768.,  4992.,  5216.,  4664.,  4896.,  5128.,
      5360.,  4784.,  5024.,  5264.,  5504.,  4904.,  5152.,  5400.,  5648.,
      5024.,  5280.,  5536.,  5792.,  5144.,  5408.,  5672.,  5936.,  5264.,
      5536.,  5808.,  6080.,  5384.,  5664.,  5944.,  6224.,  5504.,  5792.,
      6080.,  6368.,  5624.,  5920.,  6216.,  6512.,  5744.,  6048.,  6352.,
      6656.,  5864.,  6176.,  6488.,  6800.,  5984.,  6304.,  6624.,  6944.,
      6104.,  6432.,  6760.,  7088.,  6224.,  6560.,  6896.,  7232.,  7784.,
      8224.,  8664.,  9104.,  7904.,  8352.,  8800.,  9248.,  8024.,  8480.,
      8936.,  9392.,  8144.,  8608.,  9072.,  9536.,  8264.,  8736.,  9208.,
      9680.,  8384.,  8864.,  9344.,  9824.,  8504.,  8992.,  9480.,  9968.,
      8624.,  9120.,  9616.,  10112., 8744.,  9248.,  9752.,  10256., 8864.,
      9376.,  9888.,  10400., 8984.,  9504.,  10024., 10544., 9104.,  9632.,
      10160., 10688., 9224.,  9760.,  10296., 10832., 9344.,  9888.,  10432.,
      10976., 9464.,  10016., 10568., 11120., 9584.,  10144., 10704., 11264.,
      9704.,  10272., 10840., 11408., 9824.,  10400., 10976., 11552., 9944.,
      10528., 11112., 11696., 10064., 10656., 11248., 11840., 11624., 12320.,
      13016., 13712., 11744., 12448., 13152., 13856., 11864., 12576., 13288.,
      14000., 11984., 12704., 13424., 14144., 12104., 12832., 13560., 14288.,
      12224., 12960., 13696., 14432., 12344., 13088., 13832., 14576., 12464.,
      13216., 13968., 14720., 12584., 13344., 14104., 14864., 12704., 13472.,
      14240., 15008., 12824., 13600., 14376., 15152., 12944., 13728., 14512.,
      15296., 13064., 13856., 14648., 15440., 13184., 13984., 14784., 15584.,
      13304., 14112., 14920., 15728., 13424., 14240., 15056., 15872., 13544.,
      14368., 15192., 16016., 13664., 14496., 15328., 16160., 13784., 14624.,
      15464., 16304., 13904., 14752., 15600., 16448., 15464., 16416., 17368.,
      18320., 15584., 16544., 17504., 18464., 15704., 16672., 17640., 18608.,
      15824., 16800., 17776., 18752., 15944., 16928., 17912., 18896., 16064.,
      17056., 18048., 19040., 16184., 17184., 18184., 19184., 16304., 17312.,
      18320., 19328., 16424., 17440., 18456., 19472., 16544., 17568., 18592.,
      19616., 16664., 17696., 18728., 19760., 16784., 17824., 18864., 19904.,
      16904., 17952., 19000., 20048., 17024., 18080., 19136., 20192., 17144.,
      18208., 19272., 20336., 17264., 18336., 19408., 20480., 17384., 18464.,
      19544., 20624., 17504., 18592., 19680., 20768., 17624., 18720., 19816.,
      20912., 17744., 18848., 19952., 21056., 19304., 20512., 21720., 22928.,
      19424., 20640., 21856., 23072., 19544., 20768., 21992., 23216., 19664.,
      20896., 22128., 23360., 19784., 21024., 22264., 23504., 19904., 21152.,
      22400., 23648., 20024., 21280., 22536., 23792., 20144., 21408., 22672.,
      23936., 20264., 21536., 22808., 24080., 20384., 21664., 22944., 24224.,
      20504., 21792., 23080., 24368., 20624., 21920., 23216., 24512., 20744.,
      22048., 23352., 24656., 20864., 22176., 23488., 24800., 20984., 22304.,
      23624., 24944., 21104., 22432., 23760., 25088., 21224., 22560., 23896.,
      25232., 21344., 22688., 24032., 25376., 21464., 22816., 24168., 25520.,
      21584., 22944., 24304., 25664.};
  const std::array<int, 4> in_shape = {{1, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9730.,  12350., 15035., 12650., 10210., 13260., 16710., 20202., 16890.,
      13548., 16982., 21280., 25585., 21280., 16982., 13548., 16890., 20202.,
      16710., 13260., 10210., 12650., 15035., 12350., 9730.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      207., 228., 249., 270., 291., 333., 354., 375., 396.,
      417., 459., 480., 501., 522., 543., 585., 606., 627.,
      648., 669., 711., 732., 753., 774., 795.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19170., 19460., 24325., 24700., 29605., 30070., 24900., 25300., 20090.,
      20420., 26100., 26520., 32880., 33420., 39738., 40404., 33210., 33780.,
      26628., 27096., 33390., 33964., 41825., 42560., 50267., 51170., 41790.,
      42560., 33334., 33964., 26532., 27096., 33060., 33780., 39522., 40404.,
      32670., 33420., 25908., 26520., 19890., 20420., 24625., 25300., 29245.,
      30070., 24000., 24700., 18890., 19460.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      369.,  414.,  405.,  456.,  441.,  498.,  477.,  540.,  513.,  582.,
      585.,  666.,  621.,  708.,  657.,  750.,  693.,  792.,  729.,  834.,
      801.,  918.,  837.,  960.,  873.,  1002., 909.,  1044., 945.,  1086.,
      1017., 1170., 1053., 1212., 1089., 1254., 1125., 1296., 1161., 1338.,
      1233., 1422., 1269., 1464., 1305., 1506., 1341., 1548., 1377., 1590.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      38050., 38340., 38630., 38920., 48275.,  48650.,  49025.,  49400., 58745.,
      59210., 59675., 60140., 49400., 49800.,  50200.,  50600.,  39850., 40180.,
      40510., 40840., 51780., 52200., 52620.,  53040.,  65220.,  65760., 66300.,
      66840., 78810., 79476., 80142., 80808.,  65850.,  66420.,  66990., 67560.,
      52788., 53256., 53724., 54192., 66206.,  66780.,  67354.,  67928., 82915.,
      83650., 84385., 85120., 99631., 100534., 101437., 102340., 82810., 83580.,
      84350., 85120., 66038., 66668., 67298.,  67928.,  52500.,  53064., 53628.,
      54192., 65400., 66120., 66840., 67560.,  78162.,  79044.,  79926., 80808.,
      64590., 65340., 66090., 66840., 51204.,  51816.,  52428.,  53040., 39250.,
      39780., 40310., 40840., 48575., 49250.,  49925.,  50600.,  57665., 58490.,
      59315., 60140., 47300., 48000., 48700.,  49400.,  37210.,  37780., 38350.,
      38920.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      693.,  738.,  783.,  828.,  759.,  810.,  861.,  912.,  825.,  882.,
      939.,  996.,  891.,  954.,  1017., 1080., 957.,  1026., 1095., 1164.,
      1089., 1170., 1251., 1332., 1155., 1242., 1329., 1416., 1221., 1314.,
      1407., 1500., 1287., 1386., 1485., 1584., 1353., 1458., 1563., 1668.,
      1485., 1602., 1719., 1836., 1551., 1674., 1797., 1920., 1617., 1746.,
      1875., 2004., 1683., 1818., 1953., 2088., 1749., 1890., 2031., 2172.,
      1881., 2034., 2187., 2340., 1947., 2106., 2265., 2424., 2013., 2178.,
      2343., 2508., 2079., 2250., 2421., 2592., 2145., 2322., 2499., 2676.,
      2277., 2466., 2655., 2844., 2343., 2538., 2733., 2928., 2409., 2610.,
      2811., 3012., 2475., 2682., 2889., 3096., 2541., 2754., 2967., 3180.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18890., 19460., 24000., 24700., 29245., 30070., 24625., 25300., 19890.,
      20420., 25908., 26520., 32670., 33420., 39522., 40404., 33060., 33780.,
      26532., 27096., 33334., 33964., 41790., 42560., 50267., 51170., 41825.,
      42560., 33390., 33964., 26628., 27096., 33210., 33780., 39738., 40404.,
      32880., 33420., 26100., 26520., 20090., 20420., 24900., 25300., 29605.,
      30070., 24325., 24700., 19170., 19460.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      393.,  414.,  435.,  456.,  477.,  498.,  519.,  540.,  561.,  582.,
      645.,  666.,  687.,  708.,  729.,  750.,  771.,  792.,  813.,  834.,
      897.,  918.,  939.,  960.,  981.,  1002., 1023., 1044., 1065., 1086.,
      1149., 1170., 1191., 1212., 1233., 1254., 1275., 1296., 1317., 1338.,
      1401., 1422., 1443., 1464., 1485., 1506., 1527., 1548., 1569., 1590.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37220., 37780., 38340., 38920., 47275.,  48000.,  48650.,  49400., 57590.,
      58490., 59210., 60140., 48475., 49250.,  49800.,  50600.,  39140., 39780.,
      40180., 40840., 51000., 51816., 52200.,  53040.,  64290.,  65340., 65760.,
      66840., 77748., 79044., 79476., 80808.,  65010.,  66120.,  66420., 67560.,
      52152., 53064., 53256., 54192., 65548.,  66668.,  66780.,  67928., 82145.,
      83580., 83650., 85120., 98770., 100534., 100534., 102340., 82145., 83650.,
      83580., 85120., 65548., 66780., 66668.,  67928.,  52152.,  53256., 53064.,
      54192., 65010., 66420., 66120., 67560.,  77748.,  79476.,  79044., 80808.,
      64290., 65760., 65340., 66840., 51000.,  52200.,  51816.,  53040., 39140.,
      40180., 39780., 40840., 48475., 49800.,  49250.,  50600.,  57590., 59210.,
      58490., 60140., 47275., 48650., 48000.,  49400.,  37220.,  38340., 37780.,
      38920.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      702.,  786.,  738.,  828.,  774.,  870.,  810.,  912.,  846.,  954.,
      882.,  996.,  918.,  1038., 954.,  1080., 990.,  1122., 1026., 1164.,
      1134., 1290., 1170., 1332., 1206., 1374., 1242., 1416., 1278., 1458.,
      1314., 1500., 1350., 1542., 1386., 1584., 1422., 1626., 1458., 1668.,
      1566., 1794., 1602., 1836., 1638., 1878., 1674., 1920., 1710., 1962.,
      1746., 2004., 1782., 2046., 1818., 2088., 1854., 2130., 1890., 2172.,
      1998., 2298., 2034., 2340., 2070., 2382., 2106., 2424., 2142., 2466.,
      2178., 2508., 2214., 2550., 2250., 2592., 2286., 2634., 2322., 2676.,
      2430., 2802., 2466., 2844., 2502., 2886., 2538., 2928., 2574., 2970.,
      2610., 3012., 2646., 3054., 2682., 3096., 2718., 3138., 2754., 3180.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73880.,  74440.,  75000.,  75560.,  76100.,  76680.,  77260.,  77840.,
      93825.,  94550.,  95275.,  96000.,  96550.,  97300.,  98050.,  98800.,
      114280., 115180., 116080., 116980., 117490., 118420., 119350., 120280.,
      96175.,  96950.,  97725.,  98500.,  98800.,  99600.,  100400., 101200.,
      77640.,  78280.,  78920.,  79560.,  79700.,  80360.,  81020.,  81680.,
      101184., 102000., 102816., 103632., 103560., 104400., 105240., 106080.,
      127530., 128580., 129630., 130680., 130440., 131520., 132600., 133680.,
      154200., 155496., 156792., 158088., 157620., 158952., 160284., 161616.,
      128910., 130020., 131130., 132240., 131700., 132840., 133980., 135120.,
      103392., 104304., 105216., 106128., 105576., 106512., 107448., 108384.,
      129976., 131096., 132216., 133336., 132412., 133560., 134708., 135856.,
      162855., 164290., 165725., 167160., 165830., 167300., 168770., 170240.,
      195776., 197540., 199304., 201068., 199262., 201068., 202874., 204680.,
      162785., 164290., 165795., 167300., 165620., 167160., 168700., 170240.,
      129864., 131096., 132328., 133560., 132076., 133336., 134596., 135856.,
      103200., 104304., 105408., 106512., 105000., 106128., 107256., 108384.,
      128610., 130020., 131430., 132840., 130800., 132240., 133680., 135120.,
      153768., 155496., 157224., 158952., 156324., 158088., 159852., 161616.,
      127110., 128580., 130050., 131520., 129180., 130680., 132180., 133680.,
      100800., 102000., 103200., 104400., 102408., 103632., 104856., 106080.,
      77240.,  78280.,  79320.,  80360.,  78500.,  79560.,  80620.,  81680.,
      95625.,  96950.,  98275.,  99600.,  97150.,  98500.,  99850.,  101200.,
      113560., 115180., 116800., 118420., 115330., 116980., 118630., 120280.,
      93175.,  94550.,  95925.,  97300.,  94600.,  96000.,  97400.,  98800.,
      73320.,  74440.,  75560.,  76680.,  74420.,  75560.,  76700.,  77840.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1320., 1404., 1488., 1572., 1386., 1476., 1566., 1656., 1452., 1548.,
      1644., 1740., 1518., 1620., 1722., 1824., 1584., 1692., 1800., 1908.,
      1650., 1764., 1878., 1992., 1716., 1836., 1956., 2076., 1782., 1908.,
      2034., 2160., 1848., 1980., 2112., 2244., 1914., 2052., 2190., 2328.,
      2112., 2268., 2424., 2580., 2178., 2340., 2502., 2664., 2244., 2412.,
      2580., 2748., 2310., 2484., 2658., 2832., 2376., 2556., 2736., 2916.,
      2442., 2628., 2814., 3000., 2508., 2700., 2892., 3084., 2574., 2772.,
      2970., 3168., 2640., 2844., 3048., 3252., 2706., 2916., 3126., 3336.,
      2904., 3132., 3360., 3588., 2970., 3204., 3438., 3672., 3036., 3276.,
      3516., 3756., 3102., 3348., 3594., 3840., 3168., 3420., 3672., 3924.,
      3234., 3492., 3750., 4008., 3300., 3564., 3828., 4092., 3366., 3636.,
      3906., 4176., 3432., 3708., 3984., 4260., 3498., 3780., 4062., 4344.,
      3696., 3996., 4296., 4596., 3762., 4068., 4374., 4680., 3828., 4140.,
      4452., 4764., 3894., 4212., 4530., 4848., 3960., 4284., 4608., 4932.,
      4026., 4356., 4686., 5016., 4092., 4428., 4764., 5100., 4158., 4500.,
      4842., 5184., 4224., 4572., 4920., 5268., 4290., 4644., 4998., 5352.,
      4488., 4860., 5232., 5604., 4554., 4932., 5310., 5688., 4620., 5004.,
      5388., 5772., 4686., 5076., 5466., 5856., 4752., 5148., 5544., 5940.,
      4818., 5220., 5622., 6024., 4884., 5292., 5700., 6108., 4950., 5364.,
      5778., 6192., 5016., 5436., 5856., 6276., 5082., 5508., 5934., 6360.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37210., 37780., 38350., 38920., 47300.,  48000.,  48700.,  49400., 57665.,
      58490., 59315., 60140., 48575., 49250.,  49925.,  50600.,  39250., 39780.,
      40310., 40840., 51204., 51816., 52428.,  53040.,  64590.,  65340., 66090.,
      66840., 78162., 79044., 79926., 80808.,  65400.,  66120.,  66840., 67560.,
      52500., 53064., 53628., 54192., 66038.,  66668.,  67298.,  67928., 82810.,
      83580., 84350., 85120., 99631., 100534., 101437., 102340., 82915., 83650.,
      84385., 85120., 66206., 66780., 67354.,  67928.,  52788.,  53256., 53724.,
      54192., 65850., 66420., 66990., 67560.,  78810.,  79476.,  80142., 80808.,
      65220., 65760., 66300., 66840., 51780.,  52200.,  52620.,  53040., 39850.,
      40180., 40510., 40840., 49400., 49800.,  50200.,  50600.,  58745., 59210.,
      59675., 60140., 48275., 48650., 49025.,  49400.,  38050.,  38340., 38630.,
      38920.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      765.,  786.,  807.,  828.,  849.,  870.,  891.,  912.,  933.,  954.,
      975.,  996.,  1017., 1038., 1059., 1080., 1101., 1122., 1143., 1164.,
      1269., 1290., 1311., 1332., 1353., 1374., 1395., 1416., 1437., 1458.,
      1479., 1500., 1521., 1542., 1563., 1584., 1605., 1626., 1647., 1668.,
      1773., 1794., 1815., 1836., 1857., 1878., 1899., 1920., 1941., 1962.,
      1983., 2004., 2025., 2046., 2067., 2088., 2109., 2130., 2151., 2172.,
      2277., 2298., 2319., 2340., 2361., 2382., 2403., 2424., 2445., 2466.,
      2487., 2508., 2529., 2550., 2571., 2592., 2613., 2634., 2655., 2676.,
      2781., 2802., 2823., 2844., 2865., 2886., 2907., 2928., 2949., 2970.,
      2991., 3012., 3033., 3054., 3075., 3096., 3117., 3138., 3159., 3180.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73320.,  74420.,  74440.,  75560.,  75560.,  76700.,  76680.,  77840.,
      93175.,  94600.,  94550.,  96000.,  95925.,  97400.,  97300.,  98800.,
      113560., 115330., 115180., 116980., 116800., 118630., 118420., 120280.,
      95625.,  97150.,  96950.,  98500.,  98275.,  99850.,  99600.,  101200.,
      77240.,  78500.,  78280.,  79560.,  79320.,  80620.,  80360.,  81680.,
      100800., 102408., 102000., 103632., 103200., 104856., 104400., 106080.,
      127110., 129180., 128580., 130680., 130050., 132180., 131520., 133680.,
      153768., 156324., 155496., 158088., 157224., 159852., 158952., 161616.,
      128610., 130800., 130020., 132240., 131430., 133680., 132840., 135120.,
      103200., 105000., 104304., 106128., 105408., 107256., 106512., 108384.,
      129864., 132076., 131096., 133336., 132328., 134596., 133560., 135856.,
      162785., 165620., 164290., 167160., 165795., 168700., 167300., 170240.,
      195776., 199262., 197540., 201068., 199304., 202874., 201068., 204680.,
      162855., 165830., 164290., 167300., 165725., 168770., 167160., 170240.,
      129976., 132412., 131096., 133560., 132216., 134708., 133336., 135856.,
      103392., 105576., 104304., 106512., 105216., 107448., 106128., 108384.,
      128910., 131700., 130020., 132840., 131130., 133980., 132240., 135120.,
      154200., 157620., 155496., 158952., 156792., 160284., 158088., 161616.,
      127530., 130440., 128580., 131520., 129630., 132600., 130680., 133680.,
      101184., 103560., 102000., 104400., 102816., 105240., 103632., 106080.,
      77640.,  79700.,  78280.,  80360.,  78920.,  81020.,  79560.,  81680.,
      96175.,  98800.,  96950.,  99600.,  97725.,  100400., 98500.,  101200.,
      114280., 117490., 115180., 118420., 116080., 119350., 116980., 120280.,
      93825.,  96550.,  94550.,  97300.,  95275.,  98050.,  96000.,  98800.,
      73880.,  76100.,  74440.,  76680.,  75000.,  77260.,  75560.,  77840.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1368., 1530., 1404., 1572., 1440., 1614., 1476., 1656., 1512., 1698.,
      1548., 1740., 1584., 1782., 1620., 1824., 1656., 1866., 1692., 1908.,
      1728., 1950., 1764., 1992., 1800., 2034., 1836., 2076., 1872., 2118.,
      1908., 2160., 1944., 2202., 1980., 2244., 2016., 2286., 2052., 2328.,
      2232., 2538., 2268., 2580., 2304., 2622., 2340., 2664., 2376., 2706.,
      2412., 2748., 2448., 2790., 2484., 2832., 2520., 2874., 2556., 2916.,
      2592., 2958., 2628., 3000., 2664., 3042., 2700., 3084., 2736., 3126.,
      2772., 3168., 2808., 3210., 2844., 3252., 2880., 3294., 2916., 3336.,
      3096., 3546., 3132., 3588., 3168., 3630., 3204., 3672., 3240., 3714.,
      3276., 3756., 3312., 3798., 3348., 3840., 3384., 3882., 3420., 3924.,
      3456., 3966., 3492., 4008., 3528., 4050., 3564., 4092., 3600., 4134.,
      3636., 4176., 3672., 4218., 3708., 4260., 3744., 4302., 3780., 4344.,
      3960., 4554., 3996., 4596., 4032., 4638., 4068., 4680., 4104., 4722.,
      4140., 4764., 4176., 4806., 4212., 4848., 4248., 4890., 4284., 4932.,
      4320., 4974., 4356., 5016., 4392., 5058., 4428., 5100., 4464., 5142.,
      4500., 5184., 4536., 5226., 4572., 5268., 4608., 5310., 4644., 5352.,
      4824., 5562., 4860., 5604., 4896., 5646., 4932., 5688., 4968., 5730.,
      5004., 5772., 5040., 5814., 5076., 5856., 5112., 5898., 5148., 5940.,
      5184., 5982., 5220., 6024., 5256., 6066., 5292., 6108., 5328., 6150.,
      5364., 6192., 5400., 6234., 5436., 6276., 5472., 6318., 5508., 6360.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145540., 146640., 147740., 148840., 147760., 148880., 150000., 151120.,
      149980., 151120., 152260., 153400., 152200., 153360., 154520., 155680.,
      184925., 186350., 187775., 189200., 187650., 189100., 190550., 192000.,
      190375., 191850., 193325., 194800., 193100., 194600., 196100., 197600.,
      225350., 227120., 228890., 230660., 228560., 230360., 232160., 233960.,
      231770., 233600., 235430., 237260., 234980., 236840., 238700., 240560.,
      189725., 191250., 192775., 194300., 192350., 193900., 195450., 197000.,
      194975., 196550., 198125., 199700., 197600., 199200., 200800., 202400.,
      153220., 154480., 155740., 157000., 155280., 156560., 157840., 159120.,
      157340., 158640., 159940., 161240., 159400., 160720., 162040., 163360.,
      199992., 201600., 203208., 204816., 202368., 204000., 205632., 207264.,
      204744., 206400., 208056., 209712., 207120., 208800., 210480., 212160.,
      252150., 254220., 256290., 258360., 255060., 257160., 259260., 261360.,
      257970., 260100., 262230., 264360., 260880., 263040., 265200., 267360.,
      304980., 307536., 310092., 312648., 308400., 310992., 313584., 316176.,
      311820., 314448., 317076., 319704., 315240., 317904., 320568., 323232.,
      255030., 257220., 259410., 261600., 257820., 260040., 262260., 264480.,
      260610., 262860., 265110., 267360., 263400., 265680., 267960., 270240.,
      204600., 206400., 208200., 210000., 206784., 208608., 210432., 212256.,
      208968., 210816., 212664., 214512., 211152., 213024., 214896., 216768.,
      257516., 259728., 261940., 264152., 259952., 262192., 264432., 266672.,
      262388., 264656., 266924., 269192., 264824., 267120., 269416., 271712.,
      322735., 325570., 328405., 331240., 325710., 328580., 331450., 334320.,
      328685., 331590., 334495., 337400., 331660., 334600., 337540., 340480.,
      388066., 391552., 395038., 398524., 391552., 395080., 398608., 402136.,
      395038., 398608., 402178., 405748., 398524., 402136., 405748., 409360.,
      322735., 325710., 328685., 331660., 325570., 328580., 331590., 334600.,
      328405., 331450., 334495., 337540., 331240., 334320., 337400., 340480.,
      257516., 259952., 262388., 264824., 259728., 262192., 264656., 267120.,
      261940., 264432., 266924., 269416., 264152., 266672., 269192., 271712.,
      204600., 206784., 208968., 211152., 206400., 208608., 210816., 213024.,
      208200., 210432., 212664., 214896., 210000., 212256., 214512., 216768.,
      255030., 257820., 260610., 263400., 257220., 260040., 262860., 265680.,
      259410., 262260., 265110., 267960., 261600., 264480., 267360., 270240.,
      304980., 308400., 311820., 315240., 307536., 310992., 314448., 317904.,
      310092., 313584., 317076., 320568., 312648., 316176., 319704., 323232.,
      252150., 255060., 257970., 260880., 254220., 257160., 260100., 263040.,
      256290., 259260., 262230., 265200., 258360., 261360., 264360., 267360.,
      199992., 202368., 204744., 207120., 201600., 204000., 206400., 208800.,
      203208., 205632., 208056., 210480., 204816., 207264., 209712., 212160.,
      153220., 155280., 157340., 159400., 154480., 156560., 158640., 160720.,
      155740., 157840., 159940., 162040., 157000., 159120., 161240., 163360.,
      189725., 192350., 194975., 197600., 191250., 193900., 196550., 199200.,
      192775., 195450., 198125., 200800., 194300., 197000., 199700., 202400.,
      225350., 228560., 231770., 234980., 227120., 230360., 233600., 236840.,
      228890., 232160., 235430., 238700., 230660., 233960., 237260., 240560.,
      184925., 187650., 190375., 193100., 186350., 189100., 191850., 194600.,
      187775., 190550., 193325., 196100., 189200., 192000., 194800., 197600.,
      145540., 147760., 149980., 152200., 146640., 148880., 151120., 153360.,
      147740., 150000., 152260., 154520., 148840., 151120., 153400., 155680.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2574.,  2736.,  2898.,  3060.,  2640.,  2808.,  2976.,  3144.,  2706.,
      2880.,  3054.,  3228.,  2772.,  2952.,  3132.,  3312.,  2838.,  3024.,
      3210.,  3396.,  2904.,  3096.,  3288.,  3480.,  2970.,  3168.,  3366.,
      3564.,  3036.,  3240.,  3444.,  3648.,  3102.,  3312.,  3522.,  3732.,
      3168.,  3384.,  3600.,  3816.,  3234.,  3456.,  3678.,  3900.,  3300.,
      3528.,  3756.,  3984.,  3366.,  3600.,  3834.,  4068.,  3432.,  3672.,
      3912.,  4152.,  3498.,  3744.,  3990.,  4236.,  3564.,  3816.,  4068.,
      4320.,  3630.,  3888.,  4146.,  4404.,  3696.,  3960.,  4224.,  4488.,
      3762.,  4032.,  4302.,  4572.,  3828.,  4104.,  4380.,  4656.,  4158.,
      4464.,  4770.,  5076.,  4224.,  4536.,  4848.,  5160.,  4290.,  4608.,
      4926.,  5244.,  4356.,  4680.,  5004.,  5328.,  4422.,  4752.,  5082.,
      5412.,  4488.,  4824.,  5160.,  5496.,  4554.,  4896.,  5238.,  5580.,
      4620.,  4968.,  5316.,  5664.,  4686.,  5040.,  5394.,  5748.,  4752.,
      5112.,  5472.,  5832.,  4818.,  5184.,  5550.,  5916.,  4884.,  5256.,
      5628.,  6000.,  4950.,  5328.,  5706.,  6084.,  5016.,  5400.,  5784.,
      6168.,  5082.,  5472.,  5862.,  6252.,  5148.,  5544.,  5940.,  6336.,
      5214.,  5616.,  6018.,  6420.,  5280.,  5688.,  6096.,  6504.,  5346.,
      5760.,  6174.,  6588.,  5412.,  5832.,  6252.,  6672.,  5742.,  6192.,
      6642.,  7092.,  5808.,  6264.,  6720.,  7176.,  5874.,  6336.,  6798.,
      7260.,  5940.,  6408.,  6876.,  7344.,  6006.,  6480.,  6954.,  7428.,
      6072.,  6552.,  7032.,  7512.,  6138.,  6624.,  7110.,  7596.,  6204.,
      6696.,  7188.,  7680.,  6270.,  6768.,  7266.,  7764.,  6336.,  6840.,
      7344.,  7848.,  6402.,  6912.,  7422.,  7932.,  6468.,  6984.,  7500.,
      8016.,  6534.,  7056.,  7578.,  8100.,  6600.,  7128.,  7656.,  8184.,
      6666.,  7200.,  7734.,  8268.,  6732.,  7272.,  7812.,  8352.,  6798.,
      7344.,  7890.,  8436.,  6864.,  7416.,  7968.,  8520.,  6930.,  7488.,
      8046.,  8604.,  6996.,  7560.,  8124.,  8688.,  7326.,  7920.,  8514.,
      9108.,  7392.,  7992.,  8592.,  9192.,  7458.,  8064.,  8670.,  9276.,
      7524.,  8136.,  8748.,  9360.,  7590.,  8208.,  8826.,  9444.,  7656.,
      8280.,  8904.,  9528.,  7722.,  8352.,  8982.,  9612.,  7788.,  8424.,
      9060.,  9696.,  7854.,  8496.,  9138.,  9780.,  7920.,  8568.,  9216.,
      9864.,  7986.,  8640.,  9294.,  9948.,  8052.,  8712.,  9372.,  10032.,
      8118.,  8784.,  9450.,  10116., 8184.,  8856.,  9528.,  10200., 8250.,
      8928.,  9606.,  10284., 8316.,  9000.,  9684.,  10368., 8382.,  9072.,
      9762.,  10452., 8448.,  9144.,  9840.,  10536., 8514.,  9216.,  9918.,
      10620., 8580.,  9288.,  9996.,  10704., 8910.,  9648.,  10386., 11124.,
      8976.,  9720.,  10464., 11208., 9042.,  9792.,  10542., 11292., 9108.,
      9864.,  10620., 11376., 9174.,  9936.,  10698., 11460., 9240.,  10008.,
      10776., 11544., 9306.,  10080., 10854., 11628., 9372.,  10152., 10932.,
      11712., 9438.,  10224., 11010., 11796., 9504.,  10296., 11088., 11880.,
      9570.,  10368., 11166., 11964., 9636.,  10440., 11244., 12048., 9702.,
      10512., 11322., 12132., 9768.,  10584., 11400., 12216., 9834.,  10656.,
      11478., 12300., 9900.,  10728., 11556., 12384., 9966.,  10800., 11634.,
      12468., 10032., 10872., 11712., 12552., 10098., 10944., 11790., 12636.,
      10164., 11016., 11868., 12720.};
  const std::array<int, 4> in_shape = {{1, 7, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16525., 20090., 23730., 20510., 17225., 22490., 27174., 31906., 27426.,
      22910., 28770., 34594., 40425., 34594., 28770., 22910., 27426., 31906.,
      27174., 22490., 17225., 20510., 23730., 20090., 16525.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      537.,  582.,  627.,  672.,  717.,  852.,  897.,  942.,  987.,
      1032., 1167., 1212., 1257., 1302., 1347., 1482., 1527., 1572.,
      1617., 1662., 1797., 1842., 1887., 1932., 1977.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32625., 33050., 39655., 40180., 46830., 47460., 40465., 41020., 33975.,
      34450., 44365., 44980., 53592., 54348., 62909., 63812., 54060., 54852.,
      45145., 45820., 56700., 57540., 68159., 69188., 79625., 80850., 68117.,
      69188., 56630., 57540., 44995., 45820., 53844., 54852., 62615., 63812.,
      53304., 54348., 44095., 44980., 33675., 34450., 40075., 41020., 46340.,
      47460., 39205., 40180., 32225., 33050.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      993.,  1074., 1074., 1164., 1155., 1254., 1236., 1344., 1317., 1434.,
      1560., 1704., 1641., 1794., 1722., 1884., 1803., 1974., 1884., 2064.,
      2127., 2334., 2208., 2424., 2289., 2514., 2370., 2604., 2451., 2694.,
      2694., 2964., 2775., 3054., 2856., 3144., 2937., 3234., 3018., 3324.,
      3261., 3594., 3342., 3684., 3423., 3774., 3504., 3864., 3585., 3954.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      64825.,  65250.,  65675.,  66100.,  78785.,  79310.,  79835.,  80360.,
      93030.,  93660.,  94290.,  94920.,  80375.,  80930.,  81485.,  82040.,
      67475.,  67950.,  68425.,  68900.,  88115.,  88730.,  89345.,  89960.,
      106428., 107184., 107940., 108696., 124915., 125818., 126721., 127624.,
      107328., 108120., 108912., 109704., 89615.,  90290.,  90965.,  91640.,
      112560., 113400., 114240., 115080., 135289., 136318., 137347., 138376.,
      158025., 159250., 160475., 161700., 135163., 136234., 137305., 138376.,
      112350., 113260., 114170., 115080., 89165.,  89990.,  90815.,  91640.,
      106680., 107688., 108696., 109704., 124033., 125230., 126427., 127624.,
      105564., 106608., 107652., 108696., 87305.,  88190.,  89075.,  89960.,
      66575.,  67350.,  68125.,  68900.,  79205.,  80150.,  81095.,  82040.,
      91560.,  92680.,  93800.,  94920.,  77435.,  78410.,  79385.,  80360.,
      63625.,  64450.,  65275.,  66100.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1905., 1986., 2067., 2148., 2058., 2148., 2238., 2328., 2211., 2310.,
      2409., 2508., 2364., 2472., 2580., 2688., 2517., 2634., 2751., 2868.,
      2976., 3120., 3264., 3408., 3129., 3282., 3435., 3588., 3282., 3444.,
      3606., 3768., 3435., 3606., 3777., 3948., 3588., 3768., 3948., 4128.,
      4047., 4254., 4461., 4668., 4200., 4416., 4632., 4848., 4353., 4578.,
      4803., 5028., 4506., 4740., 4974., 5208., 4659., 4902., 5145., 5388.,
      5118., 5388., 5658., 5928., 5271., 5550., 5829., 6108., 5424., 5712.,
      6000., 6288., 5577., 5874., 6171., 6468., 5730., 6036., 6342., 6648.,
      6189., 6522., 6855., 7188., 6342., 6684., 7026., 7368., 6495., 6846.,
      7197., 7548., 6648., 7008., 7368., 7728., 6801., 7170., 7539., 7908.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32225., 33050., 39205., 40180., 46340., 47460., 40075., 41020., 33675.,
      34450., 44095., 44980., 53304., 54348., 62615., 63812., 53844., 54852.,
      44995., 45820., 56630., 57540., 68117., 69188., 79625., 80850., 68159.,
      69188., 56700., 57540., 45145., 45820., 54060., 54852., 62909., 63812.,
      53592., 54348., 44365., 44980., 33975., 34450., 40465., 41020., 46830.,
      47460., 39655., 40180., 32625., 33050.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1029., 1074., 1119., 1164., 1209., 1254., 1299., 1344., 1389., 1434.,
      1659., 1704., 1749., 1794., 1839., 1884., 1929., 1974., 2019., 2064.,
      2289., 2334., 2379., 2424., 2469., 2514., 2559., 2604., 2649., 2694.,
      2919., 2964., 3009., 3054., 3099., 3144., 3189., 3234., 3279., 3324.,
      3549., 3594., 3639., 3684., 3729., 3774., 3819., 3864., 3909., 3954.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63625.,  64450.,  65250.,  66100.,  77390.,  78410.,  79310.,  80360.,
      91455.,  92680.,  93660.,  94920.,  79070.,  80150.,  80930.,  82040.,
      66425.,  67350.,  67950.,  68900.,  86990.,  88190.,  88730.,  89960.,
      105132., 106608., 107184., 108696., 123466., 125230., 125818., 127624.,
      106140., 107688., 108120., 109704., 88670.,  89990.,  90290.,  91640.,
      111615., 113260., 113400., 115080., 134218., 136234., 136318., 138376.,
      156849., 159250., 159250., 161700., 134218., 136318., 136234., 138376.,
      111615., 113400., 113260., 115080., 88670.,  90290.,  89990.,  91640.,
      106140., 108120., 107688., 109704., 123466., 125818., 125230., 127624.,
      105132., 107184., 106608., 108696., 86990.,  88730.,  88190.,  89960.,
      66425.,  67950.,  67350.,  68900.,  79070.,  80930.,  80150.,  82040.,
      91455.,  93660.,  92680.,  94920.,  77390.,  79310.,  78410.,  80360.,
      63625.,  65250.,  64450.,  66100.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1905., 2058., 1986., 2148., 2067., 2238., 2148., 2328., 2229., 2418.,
      2310., 2508., 2391., 2598., 2472., 2688., 2553., 2778., 2634., 2868.,
      3039., 3318., 3120., 3408., 3201., 3498., 3282., 3588., 3363., 3678.,
      3444., 3768., 3525., 3858., 3606., 3948., 3687., 4038., 3768., 4128.,
      4173., 4578., 4254., 4668., 4335., 4758., 4416., 4848., 4497., 4938.,
      4578., 5028., 4659., 5118., 4740., 5208., 4821., 5298., 4902., 5388.,
      5307., 5838., 5388., 5928., 5469., 6018., 5550., 6108., 5631., 6198.,
      5712., 6288., 5793., 6378., 5874., 6468., 5955., 6558., 6036., 6648.,
      6441., 7098., 6522., 7188., 6603., 7278., 6684., 7368., 6765., 7458.,
      6846., 7548., 6927., 7638., 7008., 7728., 7089., 7818., 7170., 7908.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      126425., 127250., 128075., 128900., 129650., 130500., 131350., 132200.,
      153760., 154780., 155800., 156820., 157570., 158620., 159670., 160720.,
      181685., 182910., 184135., 185360., 186060., 187320., 188580., 189840.,
      157060., 158140., 159220., 160300., 160750., 161860., 162970., 164080.,
      131925., 132850., 133775., 134700., 134950., 135900., 136850., 137800.,
      172780., 173980., 175180., 176380., 176230., 177460., 178690., 179920.,
      208788., 210264., 211740., 213216., 212856., 214368., 215880., 217392.,
      245168., 246932., 248696., 250460., 249830., 251636., 253442., 255248.,
      210732., 212280., 213828., 215376., 214656., 216240., 217824., 219408.,
      176020., 177340., 178660., 179980., 179230., 180580., 181930., 183280.,
      221585., 223230., 224875., 226520., 225120., 226800., 228480., 230160.,
      266420., 268436., 270452., 272468., 270578., 272636., 274694., 276752.,
      311297., 313698., 316099., 318500., 316050., 318500., 320950., 323400.,
      266336., 268436., 270536., 272636., 270326., 272468., 274610., 276752.,
      221445., 223230., 225015., 226800., 224700., 226520., 228340., 230160.,
      175720., 177340., 178960., 180580., 178330., 179980., 181630., 183280.,
      210300., 212280., 214260., 216240., 213360., 215376., 217392., 219408.,
      244580., 246932., 249284., 251636., 248066., 250460., 252854., 255248.,
      208212., 210264., 212316., 214368., 211128., 213216., 215304., 217392.,
      172240., 173980., 175720., 177460., 174610., 176380., 178150., 179920.,
      131325., 132850., 134375., 135900., 133150., 134700., 136250., 137800.,
      156280., 158140., 160000., 161860., 158410., 160300., 162190., 164080.,
      180705., 182910., 185115., 187320., 183120., 185360., 187600., 189840.,
      152860., 154780., 156700., 158620., 154870., 156820., 158770., 160720.,
      125625., 127250., 128875., 130500., 127250., 128900., 130550., 132200.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3657.,  3810.,  3963.,  4116.,  3810.,  3972.,  4134.,  4296.,  3963.,
      4134.,  4305.,  4476.,  4116.,  4296.,  4476.,  4656.,  4269.,  4458.,
      4647.,  4836.,  4422.,  4620.,  4818.,  5016.,  4575.,  4782.,  4989.,
      5196.,  4728.,  4944.,  5160.,  5376.,  4881.,  5106.,  5331.,  5556.,
      5034.,  5268.,  5502.,  5736.,  5799.,  6078.,  6357.,  6636.,  5952.,
      6240.,  6528.,  6816.,  6105.,  6402.,  6699.,  6996.,  6258.,  6564.,
      6870.,  7176.,  6411.,  6726.,  7041.,  7356.,  6564.,  6888.,  7212.,
      7536.,  6717.,  7050.,  7383.,  7716.,  6870.,  7212.,  7554.,  7896.,
      7023.,  7374.,  7725.,  8076.,  7176.,  7536.,  7896.,  8256.,  7941.,
      8346.,  8751.,  9156.,  8094.,  8508.,  8922.,  9336.,  8247.,  8670.,
      9093.,  9516.,  8400.,  8832.,  9264.,  9696.,  8553.,  8994.,  9435.,
      9876.,  8706.,  9156.,  9606.,  10056., 8859.,  9318.,  9777.,  10236.,
      9012.,  9480.,  9948.,  10416., 9165.,  9642.,  10119., 10596., 9318.,
      9804.,  10290., 10776., 10083., 10614., 11145., 11676., 10236., 10776.,
      11316., 11856., 10389., 10938., 11487., 12036., 10542., 11100., 11658.,
      12216., 10695., 11262., 11829., 12396., 10848., 11424., 12000., 12576.,
      11001., 11586., 12171., 12756., 11154., 11748., 12342., 12936., 11307.,
      11910., 12513., 13116., 11460., 12072., 12684., 13296., 12225., 12882.,
      13539., 14196., 12378., 13044., 13710., 14376., 12531., 13206., 13881.,
      14556., 12684., 13368., 14052., 14736., 12837., 13530., 14223., 14916.,
      12990., 13692., 14394., 15096., 13143., 13854., 14565., 15276., 13296.,
      14016., 14736., 15456., 13449., 14178., 14907., 15636., 13602., 14340.,
      15078., 15816.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63625.,  64450.,  65275.,  66100.,  77435.,  78410.,  79385.,  80360.,
      91560.,  92680.,  93800.,  94920.,  79205.,  80150.,  81095.,  82040.,
      66575.,  67350.,  68125.,  68900.,  87305.,  88190.,  89075.,  89960.,
      105564., 106608., 107652., 108696., 124033., 125230., 126427., 127624.,
      106680., 107688., 108696., 109704., 89165.,  89990.,  90815.,  91640.,
      112350., 113260., 114170., 115080., 135163., 136234., 137305., 138376.,
      158025., 159250., 160475., 161700., 135289., 136318., 137347., 138376.,
      112560., 113400., 114240., 115080., 89615.,  90290.,  90965.,  91640.,
      107328., 108120., 108912., 109704., 124915., 125818., 126721., 127624.,
      106428., 107184., 107940., 108696., 88115.,  88730.,  89345.,  89960.,
      67475.,  67950.,  68425.,  68900.,  80375.,  80930.,  81485.,  82040.,
      93030.,  93660.,  94290.,  94920.,  78785.,  79310.,  79835.,  80360.,
      64825.,  65250.,  65675.,  66100.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2013., 2058., 2103., 2148., 2193., 2238., 2283., 2328., 2373., 2418.,
      2463., 2508., 2553., 2598., 2643., 2688., 2733., 2778., 2823., 2868.,
      3273., 3318., 3363., 3408., 3453., 3498., 3543., 3588., 3633., 3678.,
      3723., 3768., 3813., 3858., 3903., 3948., 3993., 4038., 4083., 4128.,
      4533., 4578., 4623., 4668., 4713., 4758., 4803., 4848., 4893., 4938.,
      4983., 5028., 5073., 5118., 5163., 5208., 5253., 5298., 5343., 5388.,
      5793., 5838., 5883., 5928., 5973., 6018., 6063., 6108., 6153., 6198.,
      6243., 6288., 6333., 6378., 6423., 6468., 6513., 6558., 6603., 6648.,
      7053., 7098., 7143., 7188., 7233., 7278., 7323., 7368., 7413., 7458.,
      7503., 7548., 7593., 7638., 7683., 7728., 7773., 7818., 7863., 7908.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      125625., 127250., 127250., 128900., 128875., 130550., 130500., 132200.,
      152860., 154870., 154780., 156820., 156700., 158770., 158620., 160720.,
      180705., 183120., 182910., 185360., 185115., 187600., 187320., 189840.,
      156280., 158410., 158140., 160300., 160000., 162190., 161860., 164080.,
      131325., 133150., 132850., 134700., 134375., 136250., 135900., 137800.,
      172240., 174610., 173980., 176380., 175720., 178150., 177460., 179920.,
      208212., 211128., 210264., 213216., 212316., 215304., 214368., 217392.,
      244580., 248066., 246932., 250460., 249284., 252854., 251636., 255248.,
      210300., 213360., 212280., 215376., 214260., 217392., 216240., 219408.,
      175720., 178330., 177340., 179980., 178960., 181630., 180580., 183280.,
      221445., 224700., 223230., 226520., 225015., 228340., 226800., 230160.,
      266336., 270326., 268436., 272468., 270536., 274610., 272636., 276752.,
      311297., 316050., 313698., 318500., 316099., 320950., 318500., 323400.,
      266420., 270578., 268436., 272636., 270452., 274694., 272468., 276752.,
      221585., 225120., 223230., 226800., 224875., 228480., 226520., 230160.,
      176020., 179230., 177340., 180580., 178660., 181930., 179980., 183280.,
      210732., 214656., 212280., 216240., 213828., 217824., 215376., 219408.,
      245168., 249830., 246932., 251636., 248696., 253442., 250460., 255248.,
      208788., 212856., 210264., 214368., 211740., 215880., 213216., 217392.,
      172780., 176230., 173980., 177460., 175180., 178690., 176380., 179920.,
      131925., 134950., 132850., 135900., 133775., 136850., 134700., 137800.,
      157060., 160750., 158140., 161860., 159220., 162970., 160300., 164080.,
      181685., 186060., 182910., 187320., 184135., 188580., 185360., 189840.,
      153760., 157570., 154780., 158620., 155800., 159670., 156820., 160720.,
      126425., 129650., 127250., 130500., 128075., 131350., 128900., 132200.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3729.,  4026.,  3810.,  4116.,  3891.,  4206.,  3972.,  4296.,  4053.,
      4386.,  4134.,  4476.,  4215.,  4566.,  4296.,  4656.,  4377.,  4746.,
      4458.,  4836.,  4539.,  4926.,  4620.,  5016.,  4701.,  5106.,  4782.,
      5196.,  4863.,  5286.,  4944.,  5376.,  5025.,  5466.,  5106.,  5556.,
      5187.,  5646.,  5268.,  5736.,  5997.,  6546.,  6078.,  6636.,  6159.,
      6726.,  6240.,  6816.,  6321.,  6906.,  6402.,  6996.,  6483.,  7086.,
      6564.,  7176.,  6645.,  7266.,  6726.,  7356.,  6807.,  7446.,  6888.,
      7536.,  6969.,  7626.,  7050.,  7716.,  7131.,  7806.,  7212.,  7896.,
      7293.,  7986.,  7374.,  8076.,  7455.,  8166.,  7536.,  8256.,  8265.,
      9066.,  8346.,  9156.,  8427.,  9246.,  8508.,  9336.,  8589.,  9426.,
      8670.,  9516.,  8751.,  9606.,  8832.,  9696.,  8913.,  9786.,  8994.,
      9876.,  9075.,  9966.,  9156.,  10056., 9237.,  10146., 9318.,  10236.,
      9399.,  10326., 9480.,  10416., 9561.,  10506., 9642.,  10596., 9723.,
      10686., 9804.,  10776., 10533., 11586., 10614., 11676., 10695., 11766.,
      10776., 11856., 10857., 11946., 10938., 12036., 11019., 12126., 11100.,
      12216., 11181., 12306., 11262., 12396., 11343., 12486., 11424., 12576.,
      11505., 12666., 11586., 12756., 11667., 12846., 11748., 12936., 11829.,
      13026., 11910., 13116., 11991., 13206., 12072., 13296., 12801., 14106.,
      12882., 14196., 12963., 14286., 13044., 14376., 13125., 14466., 13206.,
      14556., 13287., 14646., 13368., 14736., 13449., 14826., 13530., 14916.,
      13611., 15006., 13692., 15096., 13773., 15186., 13854., 15276., 13935.,
      15366., 14016., 15456., 14097., 15546., 14178., 15636., 14259., 15726.,
      14340., 15816.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      249625., 251250., 252875., 254500., 252850., 254500., 256150., 257800.,
      256075., 257750., 259425., 261100., 259300., 261000., 262700., 264400.,
      303710., 305720., 307730., 309740., 307520., 309560., 311600., 313640.,
      311330., 313400., 315470., 317540., 315140., 317240., 319340., 321440.,
      358995., 361410., 363825., 366240., 363370., 365820., 368270., 370720.,
      367745., 370230., 372715., 375200., 372120., 374640., 377160., 379680.,
      310430., 312560., 314690., 316820., 314120., 316280., 318440., 320600.,
      317810., 320000., 322190., 324380., 321500., 323720., 325940., 328160.,
      260825., 262650., 264475., 266300., 263850., 265700., 267550., 269400.,
      266875., 268750., 270625., 272500., 269900., 271800., 273700., 275600.,
      342110., 344480., 346850., 349220., 345560., 347960., 350360., 352760.,
      349010., 351440., 353870., 356300., 352460., 354920., 357380., 359840.,
      413508., 416424., 419340., 422256., 417576., 420528., 423480., 426432.,
      421644., 424632., 427620., 430608., 425712., 428736., 431760., 434784.,
      485674., 489160., 492646., 496132., 490336., 493864., 497392., 500920.,
      494998., 498568., 502138., 505708., 499660., 503272., 506884., 510496.,
      417540., 420600., 423660., 426720., 421464., 424560., 427656., 430752.,
      425388., 428520., 431652., 434784., 429312., 432480., 435648., 438816.,
      348830., 351440., 354050., 356660., 352040., 354680., 357320., 359960.,
      355250., 357920., 360590., 363260., 358460., 361160., 363860., 366560.,
      439635., 442890., 446145., 449400., 443170., 446460., 449750., 453040.,
      446705., 450030., 453355., 456680., 450240., 453600., 456960., 460320.,
      528682., 532672., 536662., 540652., 532840., 536872., 540904., 544936.,
      536998., 541072., 545146., 549220., 541156., 545272., 549388., 553504.,
      617841., 622594., 627347., 632100., 622594., 627396., 632198., 637000.,
      627347., 632198., 637049., 641900., 632100., 637000., 641900., 646800.,
      528682., 532840., 536998., 541156., 532672., 536872., 541072., 545272.,
      536662., 540904., 545146., 549388., 540652., 544936., 549220., 553504.,
      439635., 443170., 446705., 450240., 442890., 446460., 450030., 453600.,
      446145., 449750., 453355., 456960., 449400., 453040., 456680., 460320.,
      348830., 352040., 355250., 358460., 351440., 354680., 357920., 361160.,
      354050., 357320., 360590., 363860., 356660., 359960., 363260., 366560.,
      417540., 421464., 425388., 429312., 420600., 424560., 428520., 432480.,
      423660., 427656., 431652., 435648., 426720., 430752., 434784., 438816.,
      485674., 490336., 494998., 499660., 489160., 493864., 498568., 503272.,
      492646., 497392., 502138., 506884., 496132., 500920., 505708., 510496.,
      413508., 417576., 421644., 425712., 416424., 420528., 424632., 428736.,
      419340., 423480., 427620., 431760., 422256., 426432., 430608., 434784.,
      342110., 345560., 349010., 352460., 344480., 347960., 351440., 354920.,
      346850., 350360., 353870., 357380., 349220., 352760., 356300., 359840.,
      260825., 263850., 266875., 269900., 262650., 265700., 268750., 271800.,
      264475., 267550., 270625., 273700., 266300., 269400., 272500., 275600.,
      310430., 314120., 317810., 321500., 312560., 316280., 320000., 323720.,
      314690., 318440., 322190., 325940., 316820., 320600., 324380., 328160.,
      358995., 363370., 367745., 372120., 361410., 365820., 370230., 374640.,
      363825., 368270., 372715., 377160., 366240., 370720., 375200., 379680.,
      303710., 307520., 311330., 315140., 305720., 309560., 313400., 317240.,
      307730., 311600., 315470., 319340., 309740., 313640., 317540., 321440.,
      249625., 252850., 256075., 259300., 251250., 254500., 257750., 261000.,
      252875., 256150., 259425., 262700., 254500., 257800., 261100., 264400.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7161.,  7458.,  7755.,  8052.,  7314.,  7620.,  7926.,  8232.,  7467.,
      7782.,  8097.,  8412.,  7620.,  7944.,  8268.,  8592.,  7773.,  8106.,
      8439.,  8772.,  7926.,  8268.,  8610.,  8952.,  8079.,  8430.,  8781.,
      9132.,  8232.,  8592.,  8952.,  9312.,  8385.,  8754.,  9123.,  9492.,
      8538.,  8916.,  9294.,  9672.,  8691.,  9078.,  9465.,  9852.,  8844.,
      9240.,  9636.,  10032., 8997.,  9402.,  9807.,  10212., 9150.,  9564.,
      9978.,  10392., 9303.,  9726.,  10149., 10572., 9456.,  9888.,  10320.,
      10752., 9609.,  10050., 10491., 10932., 9762.,  10212., 10662., 11112.,
      9915.,  10374., 10833., 11292., 10068., 10536., 11004., 11472., 11445.,
      11994., 12543., 13092., 11598., 12156., 12714., 13272., 11751., 12318.,
      12885., 13452., 11904., 12480., 13056., 13632., 12057., 12642., 13227.,
      13812., 12210., 12804., 13398., 13992., 12363., 12966., 13569., 14172.,
      12516., 13128., 13740., 14352., 12669., 13290., 13911., 14532., 12822.,
      13452., 14082., 14712., 12975., 13614., 14253., 14892., 13128., 13776.,
      14424., 15072., 13281., 13938., 14595., 15252., 13434., 14100., 14766.,
      15432., 13587., 14262., 14937., 15612., 13740., 14424., 15108., 15792.,
      13893., 14586., 15279., 15972., 14046., 14748., 15450., 16152., 14199.,
      14910., 15621., 16332., 14352., 15072., 15792., 16512., 15729., 16530.,
      17331., 18132., 15882., 16692., 17502., 18312., 16035., 16854., 17673.,
      18492., 16188., 17016., 17844., 18672., 16341., 17178., 18015., 18852.,
      16494., 17340., 18186., 19032., 16647., 17502., 18357., 19212., 16800.,
      17664., 18528., 19392., 16953., 17826., 18699., 19572., 17106., 17988.,
      18870., 19752., 17259., 18150., 19041., 19932., 17412., 18312., 19212.,
      20112., 17565., 18474., 19383., 20292., 17718., 18636., 19554., 20472.,
      17871., 18798., 19725., 20652., 18024., 18960., 19896., 20832., 18177.,
      19122., 20067., 21012., 18330., 19284., 20238., 21192., 18483., 19446.,
      20409., 21372., 18636., 19608., 20580., 21552., 20013., 21066., 22119.,
      23172., 20166., 21228., 22290., 23352., 20319., 21390., 22461., 23532.,
      20472., 21552., 22632., 23712., 20625., 21714., 22803., 23892., 20778.,
      21876., 22974., 24072., 20931., 22038., 23145., 24252., 21084., 22200.,
      23316., 24432., 21237., 22362., 23487., 24612., 21390., 22524., 23658.,
      24792., 21543., 22686., 23829., 24972., 21696., 22848., 24000., 25152.,
      21849., 23010., 24171., 25332., 22002., 23172., 24342., 25512., 22155.,
      23334., 24513., 25692., 22308., 23496., 24684., 25872., 22461., 23658.,
      24855., 26052., 22614., 23820., 25026., 26232., 22767., 23982., 25197.,
      26412., 22920., 24144., 25368., 26592., 24297., 25602., 26907., 28212.,
      24450., 25764., 27078., 28392., 24603., 25926., 27249., 28572., 24756.,
      26088., 27420., 28752., 24909., 26250., 27591., 28932., 25062., 26412.,
      27762., 29112., 25215., 26574., 27933., 29292., 25368., 26736., 28104.,
      29472., 25521., 26898., 28275., 29652., 25674., 27060., 28446., 29832.,
      25827., 27222., 28617., 30012., 25980., 27384., 28788., 30192., 26133.,
      27546., 28959., 30372., 26286., 27708., 29130., 30552., 26439., 27870.,
      29301., 30732., 26592., 28032., 29472., 30912., 26745., 28194., 29643.,
      31092., 26898., 28356., 29814., 31272., 27051., 28518., 29985., 31452.,
      27204., 28680., 30156., 31632.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25865., 30520., 35260., 31080., 26825., 35166., 41272., 47432., 41608.,
      35742., 44947., 52528., 60116., 52528., 44947., 35742., 41608., 47432.,
      41272., 35166., 26825., 31080., 35260., 30520., 25865.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1090., 1168., 1246., 1324., 1402., 1714., 1792., 1870., 1948.,
      2026., 2338., 2416., 2494., 2572., 2650., 2962., 3040., 3118.,
      3196., 3274., 3586., 3664., 3742., 3820., 3898.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      51145.,  51730.,  60340.,  61040.,  69700., 70520., 61425.,  62160.,
      53005.,  53650.,  69486.,  70332.,  81536., 82544., 93688.,  94864.,
      82166.,  83216.,  70566.,  71484.,  88739., 89894., 103684., 105056.,
      118636., 120232., 103635., 105056., 88655., 89894., 70350.,  71484.,
      81872.,  83216.,  93304.,  94864.,  81158., 82544., 69126.,  70332.,
      52585.,  53650.,  60900.,  62160.,  69060., 70520., 59745.,  61040.,
      50605.,  51730.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2054., 2180., 2198., 2336., 2342., 2492., 2486., 2648., 2630., 2804.,
      3206., 3428., 3350., 3584., 3494., 3740., 3638., 3896., 3782., 4052.,
      4358., 4676., 4502., 4832., 4646., 4988., 4790., 5144., 4934., 5300.,
      5510., 5924., 5654., 6080., 5798., 6236., 5942., 6392., 6086., 6548.,
      6662., 7172., 6806., 7328., 6950., 7484., 7094., 7640., 7238., 7796.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      101705., 102290., 102875., 103460., 119980., 120680., 121380., 122080.,
      138580., 139400., 140220., 141040., 122115., 122850., 123585., 124320.,
      105365., 106010., 106655., 107300., 138126., 138972., 139818., 140664.,
      162064., 163072., 164080., 165088., 186200., 187376., 188552., 189728.,
      163282., 164332., 165382., 166432., 140214., 141132., 142050., 142968.,
      176323., 177478., 178633., 179788., 205996., 207368., 208740., 210112.,
      235676., 237272., 238868., 240464., 205849., 207270., 208691., 210112.,
      176071., 177310., 178549., 179788., 139566., 140700., 141834., 142968.,
      162400., 163744., 165088., 166432., 185048., 186608., 188168., 189728.,
      160930., 162316., 163702., 165088., 137046., 138252., 139458., 140664.,
      104105., 105170., 106235., 107300., 120540., 121800., 123060., 124320.,
      136660., 138120., 139580., 141040., 118195., 119490., 120785., 122080.,
      100085., 101210., 102335., 103460.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3982.,  4108.,  4234.,  4360.,  4258.,  4396.,  4534.,  4672.,  4534.,
      4684.,  4834.,  4984.,  4810.,  4972.,  5134.,  5296.,  5086.,  5260.,
      5434.,  5608.,  6190.,  6412.,  6634.,  6856.,  6466.,  6700.,  6934.,
      7168.,  6742.,  6988.,  7234.,  7480.,  7018.,  7276.,  7534.,  7792.,
      7294.,  7564.,  7834.,  8104.,  8398.,  8716.,  9034.,  9352.,  8674.,
      9004.,  9334.,  9664.,  8950.,  9292.,  9634.,  9976.,  9226.,  9580.,
      9934.,  10288., 9502.,  9868.,  10234., 10600., 10606., 11020., 11434.,
      11848., 10882., 11308., 11734., 12160., 11158., 11596., 12034., 12472.,
      11434., 11884., 12334., 12784., 11710., 12172., 12634., 13096., 12814.,
      13324., 13834., 14344., 13090., 13612., 14134., 14656., 13366., 13900.,
      14434., 14968., 13642., 14188., 14734., 15280., 13918., 14476., 15034.,
      15592.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      50605.,  51730.,  59745.,  61040.,  69060., 70520., 60900.,  62160.,
      52585.,  53650.,  69126.,  70332.,  81158., 82544., 93304.,  94864.,
      81872.,  83216.,  70350.,  71484.,  88655., 89894., 103635., 105056.,
      118636., 120232., 103684., 105056., 88739., 89894., 70566.,  71484.,
      82166.,  83216.,  93688.,  94864.,  81536., 82544., 69486.,  70332.,
      53005.,  53650.,  61425.,  62160.,  69700., 70520., 60340.,  61040.,
      51145.,  51730.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2102., 2180., 2258., 2336., 2414., 2492., 2570., 2648., 2726., 2804.,
      3350., 3428., 3506., 3584., 3662., 3740., 3818., 3896., 3974., 4052.,
      4598., 4676., 4754., 4832., 4910., 4988., 5066., 5144., 5222., 5300.,
      5846., 5924., 6002., 6080., 6158., 6236., 6314., 6392., 6470., 6548.,
      7094., 7172., 7250., 7328., 7406., 7484., 7562., 7640., 7718., 7796.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      100070., 101210., 102290., 103460., 118125., 119490., 120680., 122080.,
      136520., 138120., 139400., 141040., 120365., 121800., 122850., 124320.,
      103910., 105170., 106010., 107300., 136596., 138252., 138972., 140664.,
      160342., 162316., 163072., 165088., 184304., 186608., 187376., 189728.,
      161686., 163744., 164332., 166432., 138900., 140700., 141132., 142968.,
      175042., 177310., 177478., 179788., 204575., 207270., 207368., 210112.,
      234136., 237272., 237272., 240464., 204575., 207368., 207270., 210112.,
      175042., 177478., 177310., 179788., 138900., 141132., 140700., 142968.,
      161686., 164332., 163744., 166432., 184304., 187376., 186608., 189728.,
      160342., 163072., 162316., 165088., 136596., 138972., 138252., 140664.,
      103910., 106010., 105170., 107300., 120365., 122850., 121800., 124320.,
      136520., 139400., 138120., 141040., 118125., 120680., 119490., 122080.,
      100070., 102290., 101210., 103460.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3964.,  4204.,  4108.,  4360.,  4252.,  4516.,  4396.,  4672.,  4540.,
      4828.,  4684.,  4984.,  4828.,  5140.,  4972.,  5296.,  5116.,  5452.,
      5260.,  5608.,  6268.,  6700.,  6412.,  6856.,  6556.,  7012.,  6700.,
      7168.,  6844.,  7324.,  6988.,  7480.,  7132.,  7636.,  7276.,  7792.,
      7420.,  7948.,  7564.,  8104.,  8572.,  9196.,  8716.,  9352.,  8860.,
      9508.,  9004.,  9664.,  9148.,  9820.,  9292.,  9976.,  9436.,  10132.,
      9580.,  10288., 9724.,  10444., 9868.,  10600., 10876., 11692., 11020.,
      11848., 11164., 12004., 11308., 12160., 11452., 12316., 11596., 12472.,
      11740., 12628., 11884., 12784., 12028., 12940., 12172., 13096., 13180.,
      14188., 13324., 14344., 13468., 14500., 13612., 14656., 13756., 14812.,
      13900., 14968., 14044., 15124., 14188., 15280., 14332., 15436., 14476.,
      15592.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      199000., 200140., 201280., 202420., 203410., 204580., 205750., 206920.,
      234885., 236250., 237615., 238980., 239960., 241360., 242760., 244160.,
      271440., 273040., 274640., 276240., 277160., 278800., 280440., 282080.,
      239295., 240730., 242165., 243600., 244230., 245700., 247170., 248640.,
      206560., 207820., 209080., 210340., 210730., 212020., 213310., 214600.,
      271536., 273192., 274848., 276504., 276252., 277944., 279636., 281328.,
      318710., 320684., 322658., 324632., 324128., 326144., 328160., 330176.,
      366304., 368608., 370912., 373216., 372400., 374752., 377104., 379456.,
      321314., 323372., 325430., 327488., 326564., 328664., 330764., 332864.,
      276000., 277800., 279600., 281400., 280428., 282264., 284100., 285936.,
      347816., 350084., 352352., 354620., 352646., 354956., 357266., 359576.,
      406455., 409150., 411845., 414540., 411992., 414736., 417480., 420224.,
      465136., 468272., 471408., 474544., 471352., 474544., 477736., 480928.,
      406357., 409150., 411943., 414736., 411698., 414540., 417382., 420224.,
      347648., 350084., 352520., 354956., 352142., 354620., 357098., 359576.,
      275568., 277800., 280032., 282264., 279132., 281400., 283668., 285936.,
      320726., 323372., 326018., 328664., 324800., 327488., 330176., 332864.,
      365536., 368608., 371680., 374752., 370096., 373216., 376336., 379456.,
      317954., 320684., 323414., 326144., 321860., 324632., 327404., 330176.,
      270816., 273192., 275568., 277944., 274092., 276504., 278916., 281328.,
      205720., 207820., 209920., 212020., 208210., 210340., 212470., 214600.,
      238245., 240730., 243215., 245700., 241080., 243600., 246120., 248640.,
      270160., 273040., 275920., 278800., 273320., 276240., 279160., 282080.,
      233695., 236250., 238805., 241360., 236390., 238980., 241570., 244160.,
      197920., 200140., 202360., 204580., 200170., 202420., 204670., 206920.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7688.,  7928.,  8168.,  8408.,  7964.,  8216.,  8468.,  8720.,  8240.,
      8504.,  8768.,  9032.,  8516.,  8792.,  9068.,  9344.,  8792.,  9080.,
      9368.,  9656.,  9068.,  9368.,  9668.,  9968.,  9344.,  9656.,  9968.,
      10280., 9620.,  9944.,  10268., 10592., 9896.,  10232., 10568., 10904.,
      10172., 10520., 10868., 11216., 12104., 12536., 12968., 13400., 12380.,
      12824., 13268., 13712., 12656., 13112., 13568., 14024., 12932., 13400.,
      13868., 14336., 13208., 13688., 14168., 14648., 13484., 13976., 14468.,
      14960., 13760., 14264., 14768., 15272., 14036., 14552., 15068., 15584.,
      14312., 14840., 15368., 15896., 14588., 15128., 15668., 16208., 16520.,
      17144., 17768., 18392., 16796., 17432., 18068., 18704., 17072., 17720.,
      18368., 19016., 17348., 18008., 18668., 19328., 17624., 18296., 18968.,
      19640., 17900., 18584., 19268., 19952., 18176., 18872., 19568., 20264.,
      18452., 19160., 19868., 20576., 18728., 19448., 20168., 20888., 19004.,
      19736., 20468., 21200., 20936., 21752., 22568., 23384., 21212., 22040.,
      22868., 23696., 21488., 22328., 23168., 24008., 21764., 22616., 23468.,
      24320., 22040., 22904., 23768., 24632., 22316., 23192., 24068., 24944.,
      22592., 23480., 24368., 25256., 22868., 23768., 24668., 25568., 23144.,
      24056., 24968., 25880., 23420., 24344., 25268., 26192., 25352., 26360.,
      27368., 28376., 25628., 26648., 27668., 28688., 25904., 26936., 27968.,
      29000., 26180., 27224., 28268., 29312., 26456., 27512., 28568., 29624.,
      26732., 27800., 28868., 29936., 27008., 28088., 29168., 30248., 27284.,
      28376., 29468., 30560., 27560., 28664., 29768., 30872., 27836., 28952.,
      30068., 31184.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      100085., 101210., 102335., 103460., 118195., 119490., 120785., 122080.,
      136660., 138120., 139580., 141040., 120540., 121800., 123060., 124320.,
      104105., 105170., 106235., 107300., 137046., 138252., 139458., 140664.,
      160930., 162316., 163702., 165088., 185048., 186608., 188168., 189728.,
      162400., 163744., 165088., 166432., 139566., 140700., 141834., 142968.,
      176071., 177310., 178549., 179788., 205849., 207270., 208691., 210112.,
      235676., 237272., 238868., 240464., 205996., 207368., 208740., 210112.,
      176323., 177478., 178633., 179788., 140214., 141132., 142050., 142968.,
      163282., 164332., 165382., 166432., 186200., 187376., 188552., 189728.,
      162064., 163072., 164080., 165088., 138126., 138972., 139818., 140664.,
      105365., 106010., 106655., 107300., 122115., 122850., 123585., 124320.,
      138580., 139400., 140220., 141040., 119980., 120680., 121380., 122080.,
      101705., 102290., 102875., 103460.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4126.,  4204.,  4282.,  4360.,  4438.,  4516.,  4594.,  4672.,  4750.,
      4828.,  4906.,  4984.,  5062.,  5140.,  5218.,  5296.,  5374.,  5452.,
      5530.,  5608.,  6622.,  6700.,  6778.,  6856.,  6934.,  7012.,  7090.,
      7168.,  7246.,  7324.,  7402.,  7480.,  7558.,  7636.,  7714.,  7792.,
      7870.,  7948.,  8026.,  8104.,  9118.,  9196.,  9274.,  9352.,  9430.,
      9508.,  9586.,  9664.,  9742.,  9820.,  9898.,  9976.,  10054., 10132.,
      10210., 10288., 10366., 10444., 10522., 10600., 11614., 11692., 11770.,
      11848., 11926., 12004., 12082., 12160., 12238., 12316., 12394., 12472.,
      12550., 12628., 12706., 12784., 12862., 12940., 13018., 13096., 14110.,
      14188., 14266., 14344., 14422., 14500., 14578., 14656., 14734., 14812.,
      14890., 14968., 15046., 15124., 15202., 15280., 15358., 15436., 15514.,
      15592.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      197920., 200170., 200140., 202420., 202360., 204670., 204580., 206920.,
      233695., 236390., 236250., 238980., 238805., 241570., 241360., 244160.,
      270160., 273320., 273040., 276240., 275920., 279160., 278800., 282080.,
      238245., 241080., 240730., 243600., 243215., 246120., 245700., 248640.,
      205720., 208210., 207820., 210340., 209920., 212470., 212020., 214600.,
      270816., 274092., 273192., 276504., 275568., 278916., 277944., 281328.,
      317954., 321860., 320684., 324632., 323414., 327404., 326144., 330176.,
      365536., 370096., 368608., 373216., 371680., 376336., 374752., 379456.,
      320726., 324800., 323372., 327488., 326018., 330176., 328664., 332864.,
      275568., 279132., 277800., 281400., 280032., 283668., 282264., 285936.,
      347648., 352142., 350084., 354620., 352520., 357098., 354956., 359576.,
      406357., 411698., 409150., 414540., 411943., 417382., 414736., 420224.,
      465136., 471352., 468272., 474544., 471408., 477736., 474544., 480928.,
      406455., 411992., 409150., 414736., 411845., 417480., 414540., 420224.,
      347816., 352646., 350084., 354956., 352352., 357266., 354620., 359576.,
      276000., 280428., 277800., 282264., 279600., 284100., 281400., 285936.,
      321314., 326564., 323372., 328664., 325430., 330764., 327488., 332864.,
      366304., 372400., 368608., 374752., 370912., 377104., 373216., 379456.,
      318710., 324128., 320684., 326144., 322658., 328160., 324632., 330176.,
      271536., 276252., 273192., 277944., 274848., 279636., 276504., 281328.,
      206560., 210730., 207820., 212020., 209080., 213310., 210340., 214600.,
      239295., 244230., 240730., 245700., 242165., 247170., 243600., 248640.,
      271440., 277160., 273040., 278800., 274640., 280440., 276240., 282080.,
      234885., 239960., 236250., 241360., 237615., 242760., 238980., 244160.,
      199000., 203410., 200140., 204580., 201280., 205750., 202420., 206920.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7784.,  8252.,  7928.,  8408.,  8072.,  8564.,  8216.,  8720.,  8360.,
      8876.,  8504.,  9032.,  8648.,  9188.,  8792.,  9344.,  8936.,  9500.,
      9080.,  9656.,  9224.,  9812.,  9368.,  9968.,  9512.,  10124., 9656.,
      10280., 9800.,  10436., 9944.,  10592., 10088., 10748., 10232., 10904.,
      10376., 11060., 10520., 11216., 12392., 13244., 12536., 13400., 12680.,
      13556., 12824., 13712., 12968., 13868., 13112., 14024., 13256., 14180.,
      13400., 14336., 13544., 14492., 13688., 14648., 13832., 14804., 13976.,
      14960., 14120., 15116., 14264., 15272., 14408., 15428., 14552., 15584.,
      14696., 15740., 14840., 15896., 14984., 16052., 15128., 16208., 17000.,
      18236., 17144., 18392., 17288., 18548., 17432., 18704., 17576., 18860.,
      17720., 19016., 17864., 19172., 18008., 19328., 18152., 19484., 18296.,
      19640., 18440., 19796., 18584., 19952., 18728., 20108., 18872., 20264.,
      19016., 20420., 19160., 20576., 19304., 20732., 19448., 20888., 19592.,
      21044., 19736., 21200., 21608., 23228., 21752., 23384., 21896., 23540.,
      22040., 23696., 22184., 23852., 22328., 24008., 22472., 24164., 22616.,
      24320., 22760., 24476., 22904., 24632., 23048., 24788., 23192., 24944.,
      23336., 25100., 23480., 25256., 23624., 25412., 23768., 25568., 23912.,
      25724., 24056., 25880., 24200., 26036., 24344., 26192., 26216., 28220.,
      26360., 28376., 26504., 28532., 26648., 28688., 26792., 28844., 26936.,
      29000., 27080., 29156., 27224., 29312., 27368., 29468., 27512., 29624.,
      27656., 29780., 27800., 29936., 27944., 30092., 28088., 30248., 28232.,
      30404., 28376., 30560., 28520., 30716., 28664., 30872., 28808., 31028.,
      28952., 31184.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      393590., 395840., 398090., 400340., 398000., 400280., 402560., 404840.,
      402410., 404720., 407030., 409340., 406820., 409160., 411500., 413840.,
      464695., 467390., 470085., 472780., 469770., 472500., 475230., 477960.,
      474845., 477610., 480375., 483140., 479920., 482720., 485520., 488320.,
      537160., 540320., 543480., 546640., 542880., 546080., 549280., 552480.,
      548600., 551840., 555080., 558320., 554320., 557600., 560880., 564160.,
      473655., 476490., 479325., 482160., 478590., 481460., 484330., 487200.,
      483525., 486430., 489335., 492240., 488460., 491400., 494340., 497280.,
      408950., 411440., 413930., 416420., 413120., 415640., 418160., 420680.,
      417290., 419840., 422390., 424940., 421460., 424040., 426620., 429200.,
      538356., 541632., 544908., 548184., 543072., 546384., 549696., 553008.,
      547788., 551136., 554484., 557832., 552504., 555888., 559272., 562656.,
      632002., 635908., 639814., 643720., 637420., 641368., 645316., 649264.,
      642838., 646828., 650818., 654808., 648256., 652288., 656320., 660352.,
      726512., 731072., 735632., 740192., 732608., 737216., 741824., 746432.,
      738704., 743360., 748016., 752672., 744800., 749504., 754208., 758912.,
      637378., 641452., 645526., 649600., 642628., 646744., 650860., 654976.,
      647878., 652036., 656194., 660352., 653128., 657328., 661528., 665728.,
      547572., 551136., 554700., 558264., 552000., 555600., 559200., 562800.,
      556428., 560064., 563700., 567336., 560856., 564528., 568200., 571872.,
      690802., 695296., 699790., 704284., 695632., 700168., 704704., 709240.,
      700462., 705040., 709618., 714196., 705292., 709912., 714532., 719152.,
      807373., 812714., 818055., 823396., 812910., 818300., 823690., 829080.,
      818447., 823886., 829325., 834764., 823984., 829472., 834960., 840448.,
      924056., 930272., 936488., 942704., 930272., 936544., 942816., 949088.,
      936488., 942816., 949144., 955472., 942704., 949088., 955472., 961856.,
      807373., 812910., 818447., 823984., 812714., 818300., 823886., 829472.,
      818055., 823690., 829325., 834960., 823396., 829080., 834764., 840448.,
      690802., 695632., 700462., 705292., 695296., 700168., 705040., 709912.,
      699790., 704704., 709618., 714532., 704284., 709240., 714196., 719152.,
      547572., 552000., 556428., 560856., 551136., 555600., 560064., 564528.,
      554700., 559200., 563700., 568200., 558264., 562800., 567336., 571872.,
      637378., 642628., 647878., 653128., 641452., 646744., 652036., 657328.,
      645526., 650860., 656194., 661528., 649600., 654976., 660352., 665728.,
      726512., 732608., 738704., 744800., 731072., 737216., 743360., 749504.,
      735632., 741824., 748016., 754208., 740192., 746432., 752672., 758912.,
      632002., 637420., 642838., 648256., 635908., 641368., 646828., 652288.,
      639814., 645316., 650818., 656320., 643720., 649264., 654808., 660352.,
      538356., 543072., 547788., 552504., 541632., 546384., 551136., 555888.,
      544908., 549696., 554484., 559272., 548184., 553008., 557832., 562656.,
      408950., 413120., 417290., 421460., 411440., 415640., 419840., 424040.,
      413930., 418160., 422390., 426620., 416420., 420680., 424940., 429200.,
      473655., 478590., 483525., 488460., 476490., 481460., 486430., 491400.,
      479325., 484330., 489335., 494340., 482160., 487200., 492240., 497280.,
      537160., 542880., 548600., 554320., 540320., 546080., 551840., 557600.,
      543480., 549280., 555080., 560880., 546640., 552480., 558320., 564160.,
      464695., 469770., 474845., 479920., 467390., 472500., 477610., 482720.,
      470085., 475230., 480375., 485520., 472780., 477960., 483140., 488320.,
      393590., 398000., 402410., 406820., 395840., 400280., 404720., 409160.,
      398090., 402560., 407030., 411500., 400340., 404840., 409340., 413840.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15100., 15568., 16036., 16504., 15376., 15856., 16336., 16816., 15652.,
      16144., 16636., 17128., 15928., 16432., 16936., 17440., 16204., 16720.,
      17236., 17752., 16480., 17008., 17536., 18064., 16756., 17296., 17836.,
      18376., 17032., 17584., 18136., 18688., 17308., 17872., 18436., 19000.,
      17584., 18160., 18736., 19312., 17860., 18448., 19036., 19624., 18136.,
      18736., 19336., 19936., 18412., 19024., 19636., 20248., 18688., 19312.,
      19936., 20560., 18964., 19600., 20236., 20872., 19240., 19888., 20536.,
      21184., 19516., 20176., 20836., 21496., 19792., 20464., 21136., 21808.,
      20068., 20752., 21436., 22120., 20344., 21040., 21736., 22432., 23932.,
      24784., 25636., 26488., 24208., 25072., 25936., 26800., 24484., 25360.,
      26236., 27112., 24760., 25648., 26536., 27424., 25036., 25936., 26836.,
      27736., 25312., 26224., 27136., 28048., 25588., 26512., 27436., 28360.,
      25864., 26800., 27736., 28672., 26140., 27088., 28036., 28984., 26416.,
      27376., 28336., 29296., 26692., 27664., 28636., 29608., 26968., 27952.,
      28936., 29920., 27244., 28240., 29236., 30232., 27520., 28528., 29536.,
      30544., 27796., 28816., 29836., 30856., 28072., 29104., 30136., 31168.,
      28348., 29392., 30436., 31480., 28624., 29680., 30736., 31792., 28900.,
      29968., 31036., 32104., 29176., 30256., 31336., 32416., 32764., 34000.,
      35236., 36472., 33040., 34288., 35536., 36784., 33316., 34576., 35836.,
      37096., 33592., 34864., 36136., 37408., 33868., 35152., 36436., 37720.,
      34144., 35440., 36736., 38032., 34420., 35728., 37036., 38344., 34696.,
      36016., 37336., 38656., 34972., 36304., 37636., 38968., 35248., 36592.,
      37936., 39280., 35524., 36880., 38236., 39592., 35800., 37168., 38536.,
      39904., 36076., 37456., 38836., 40216., 36352., 37744., 39136., 40528.,
      36628., 38032., 39436., 40840., 36904., 38320., 39736., 41152., 37180.,
      38608., 40036., 41464., 37456., 38896., 40336., 41776., 37732., 39184.,
      40636., 42088., 38008., 39472., 40936., 42400., 41596., 43216., 44836.,
      46456., 41872., 43504., 45136., 46768., 42148., 43792., 45436., 47080.,
      42424., 44080., 45736., 47392., 42700., 44368., 46036., 47704., 42976.,
      44656., 46336., 48016., 43252., 44944., 46636., 48328., 43528., 45232.,
      46936., 48640., 43804., 45520., 47236., 48952., 44080., 45808., 47536.,
      49264., 44356., 46096., 47836., 49576., 44632., 46384., 48136., 49888.,
      44908., 46672., 48436., 50200., 45184., 46960., 48736., 50512., 45460.,
      47248., 49036., 50824., 45736., 47536., 49336., 51136., 46012., 47824.,
      49636., 51448., 46288., 48112., 49936., 51760., 46564., 48400., 50236.,
      52072., 46840., 48688., 50536., 52384., 50428., 52432., 54436., 56440.,
      50704., 52720., 54736., 56752., 50980., 53008., 55036., 57064., 51256.,
      53296., 55336., 57376., 51532., 53584., 55636., 57688., 51808., 53872.,
      55936., 58000., 52084., 54160., 56236., 58312., 52360., 54448., 56536.,
      58624., 52636., 54736., 56836., 58936., 52912., 55024., 57136., 59248.,
      53188., 55312., 57436., 59560., 53464., 55600., 57736., 59872., 53740.,
      55888., 58036., 60184., 54016., 56176., 58336., 60496., 54292., 56464.,
      58636., 60808., 54568., 56752., 58936., 61120., 54844., 57040., 59236.,
      61432., 55120., 57328., 59536., 61744., 55396., 57616., 59836., 62056.,
      55672., 57904., 60136., 62368.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15780., 19950., 24198., 20310., 16356., 20426., 25690., 31003., 25900.,
      20762., 25264., 31640., 38024., 31640., 25264., 20762., 25900., 31003.,
      25690., 20426., 16356., 20310., 24198., 19950., 15780.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      500.,  536.,  572.,  608.,  644.,  716.,  752.,  788.,  824.,
      860.,  932.,  968.,  1004., 1040., 1076., 1148., 1184., 1220.,
      1256., 1292., 1364., 1400., 1436., 1472., 1508.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31140., 31560., 39360., 39900., 47730., 48396., 40050., 40620., 32244.,
      32712., 40278., 40852., 50645., 51380., 61103., 62006., 51030., 51800.,
      40894., 41524., 49776., 50528., 62320., 63280., 74872., 76048., 62280.,
      63280., 49712., 50528., 40782., 41524., 50855., 51800., 60851., 62006.,
      50400., 51380., 40054., 40852., 32004., 32712., 39720., 40620., 47298.,
      48396., 38970., 39900., 30804., 31560.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      916.,  1000., 980.,  1072., 1044., 1144., 1108., 1216., 1172., 1288.,
      1300., 1432., 1364., 1504., 1428., 1576., 1492., 1648., 1556., 1720.,
      1684., 1864., 1748., 1936., 1812., 2008., 1876., 2080., 1940., 2152.,
      2068., 2296., 2132., 2368., 2196., 2440., 2260., 2512., 2324., 2584.,
      2452., 2728., 2516., 2800., 2580., 2872., 2644., 2944., 2708., 3016.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61860.,  62280.,  62700.,  63120.,  78180.,  78720.,  79260.,  79800.,
      94794.,  95460.,  96126.,  96792.,  79530.,  80100.,  80670.,  81240.,
      64020.,  64488.,  64956.,  65424.,  79982.,  80556.,  81130.,  81704.,
      100555., 101290., 102025., 102760., 121303., 122206., 123109., 124012.,
      101290., 102060., 102830., 103600., 81158.,  81788.,  82418.,  83048.,
      98800.,  99552.,  100304., 101056., 123680., 124640., 125600., 126560.,
      148568., 149744., 150920., 152096., 123560., 124560., 125560., 126560.,
      98608.,  99424.,  100240., 101056., 80822.,  81564.,  82306.,  83048.,
      100765., 101710., 102655., 103600., 120547., 121702., 122857., 124012.,
      99820.,  100800., 101780., 102760., 79310.,  80108.,  80906.,  81704.,
      63300.,  64008.,  64716.,  65424.,  78540.,  79440.,  80340.,  81240.,
      93498.,  94596.,  95694.,  96792.,  77010.,  77940.,  78870.,  79800.,
      60852.,  61608.,  62364.,  63120.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1748., 1832., 1916., 2000., 1868., 1960., 2052., 2144., 1988., 2088.,
      2188., 2288., 2108., 2216., 2324., 2432., 2228., 2344., 2460., 2576.,
      2468., 2600., 2732., 2864., 2588., 2728., 2868., 3008., 2708., 2856.,
      3004., 3152., 2828., 2984., 3140., 3296., 2948., 3112., 3276., 3440.,
      3188., 3368., 3548., 3728., 3308., 3496., 3684., 3872., 3428., 3624.,
      3820., 4016., 3548., 3752., 3956., 4160., 3668., 3880., 4092., 4304.,
      3908., 4136., 4364., 4592., 4028., 4264., 4500., 4736., 4148., 4392.,
      4636., 4880., 4268., 4520., 4772., 5024., 4388., 4648., 4908., 5168.,
      4628., 4904., 5180., 5456., 4748., 5032., 5316., 5600., 4868., 5160.,
      5452., 5744., 4988., 5288., 5588., 5888., 5108., 5416., 5724., 6032.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30804., 31560., 38970., 39900., 47298., 48396., 39720., 40620., 32004.,
      32712., 40054., 40852., 50400., 51380., 60851., 62006., 50855., 51800.,
      40782., 41524., 49712., 50528., 62280., 63280., 74872., 76048., 62320.,
      63280., 49776., 50528., 40894., 41524., 51030., 51800., 61103., 62006.,
      50645., 51380., 40278., 40852., 32244., 32712., 40050., 40620., 47730.,
      48396., 39360., 39900., 31140., 31560.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      964.,  1000., 1036., 1072., 1108., 1144., 1180., 1216., 1252., 1288.,
      1396., 1432., 1468., 1504., 1540., 1576., 1612., 1648., 1684., 1720.,
      1828., 1864., 1900., 1936., 1972., 2008., 2044., 2080., 2116., 2152.,
      2260., 2296., 2332., 2368., 2404., 2440., 2476., 2512., 2548., 2584.,
      2692., 2728., 2764., 2800., 2836., 2872., 2908., 2944., 2980., 3016.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60792.,  61608.,  62280.,  63120.,  76890.,  77940.,  78720.,  79800.,
      93300.,  94596.,  95460.,  96792.,  78330.,  79440.,  80100.,  81240.,
      63096.,  64008.,  64488.,  65424.,  78988.,  80108.,  80556.,  81704.,
      99365.,  100800., 101290., 102760., 119938., 121702., 122206., 124012.,
      100205., 101710., 102060., 103600., 80332.,  81564.,  81788.,  83048.,
      97952.,  99424.,  99552.,  101056., 122680., 124560., 124640., 126560.,
      147440., 149744., 149744., 152096., 122680., 124640., 124560., 126560.,
      97952.,  99552.,  99424.,  101056., 80332.,  81788.,  81564.,  83048.,
      100205., 102060., 101710., 103600., 119938., 122206., 121702., 124012.,
      99365.,  101290., 100800., 102760., 78988.,  80556.,  80108.,  81704.,
      63096.,  64488.,  64008.,  65424.,  78330.,  80100.,  79440.,  81240.,
      93300.,  95460.,  94596.,  96792.,  76890.,  78720.,  77940.,  79800.,
      60792.,  62280.,  61608.,  63120.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1768., 1928., 1832., 2000., 1896., 2072., 1960., 2144., 2024., 2216.,
      2088., 2288., 2152., 2360., 2216., 2432., 2280., 2504., 2344., 2576.,
      2536., 2792., 2600., 2864., 2664., 2936., 2728., 3008., 2792., 3080.,
      2856., 3152., 2920., 3224., 2984., 3296., 3048., 3368., 3112., 3440.,
      3304., 3656., 3368., 3728., 3432., 3800., 3496., 3872., 3560., 3944.,
      3624., 4016., 3688., 4088., 3752., 4160., 3816., 4232., 3880., 4304.,
      4072., 4520., 4136., 4592., 4200., 4664., 4264., 4736., 4328., 4808.,
      4392., 4880., 4456., 4952., 4520., 5024., 4584., 5096., 4648., 5168.,
      4840., 5384., 4904., 5456., 4968., 5528., 5032., 5600., 5096., 5672.,
      5160., 5744., 5224., 5816., 5288., 5888., 5352., 5960., 5416., 6032.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120768., 121584., 122400., 123216., 123720., 124560., 125400., 126240.,
      152730., 153780., 154830., 155880., 156360., 157440., 158520., 159600.,
      185304., 186600., 187896., 189192., 189588., 190920., 192252., 193584.,
      155550., 156660., 157770., 158880., 159060., 160200., 161340., 162480.,
      125280., 126192., 127104., 128016., 128040., 128976., 129912., 130848.,
      156856., 157976., 159096., 160216., 159964., 161112., 162260., 163408.,
      197295., 198730., 200165., 201600., 201110., 202580., 204050., 205520.,
      238112., 239876., 241640., 243404., 242606., 244412., 246218., 248024.,
      198905., 200410., 201915., 203420., 202580., 204120., 205660., 207200.,
      159432., 160664., 161896., 163128., 162316., 163576., 164836., 166096.,
      194432., 195904., 197376., 198848., 197600., 199104., 200608., 202112.,
      243480., 245360., 247240., 249120., 247360., 249280., 251200., 253120.,
      292576., 294880., 297184., 299488., 297136., 299488., 301840., 304192.,
      243400., 245360., 247320., 249280., 247120., 249120., 251120., 253120.,
      194304., 195904., 197504., 199104., 197216., 198848., 200480., 202112.,
      159208., 160664., 162120., 163576., 161644., 163128., 164612., 166096.,
      198555., 200410., 202265., 204120., 201530., 203420., 205310., 207200.,
      237608., 239876., 242144., 244412., 241094., 243404., 245714., 248024.,
      196805., 198730., 200655., 202580., 199640., 201600., 203560., 205520.,
      156408., 157976., 159544., 161112., 158620., 160216., 161812., 163408.,
      124800., 126192., 127584., 128976., 126600., 128016., 129432., 130848.,
      154890., 156660., 158430., 160200., 157080., 158880., 160680., 162480.,
      184440., 186600., 188760., 190920., 186996., 189192., 191388., 193584.,
      151950., 153780., 155610., 157440., 154020., 155880., 157740., 159600.,
      120096., 121584., 123072., 124560., 121704., 123216., 124728., 126240.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3376.,  3536.,  3696.,  3856.,  3496.,  3664.,  3832.,  4000.,  3616.,
      3792.,  3968.,  4144.,  3736.,  3920.,  4104.,  4288.,  3856.,  4048.,
      4240.,  4432.,  3976.,  4176.,  4376.,  4576.,  4096.,  4304.,  4512.,
      4720.,  4216.,  4432.,  4648.,  4864.,  4336.,  4560.,  4784.,  5008.,
      4456.,  4688.,  4920.,  5152.,  4816.,  5072.,  5328.,  5584.,  4936.,
      5200.,  5464.,  5728.,  5056.,  5328.,  5600.,  5872.,  5176.,  5456.,
      5736.,  6016.,  5296.,  5584.,  5872.,  6160.,  5416.,  5712.,  6008.,
      6304.,  5536.,  5840.,  6144.,  6448.,  5656.,  5968.,  6280.,  6592.,
      5776.,  6096.,  6416.,  6736.,  5896.,  6224.,  6552.,  6880.,  6256.,
      6608.,  6960.,  7312.,  6376.,  6736.,  7096.,  7456.,  6496.,  6864.,
      7232.,  7600.,  6616.,  6992.,  7368.,  7744.,  6736.,  7120.,  7504.,
      7888.,  6856.,  7248.,  7640.,  8032.,  6976.,  7376.,  7776.,  8176.,
      7096.,  7504.,  7912.,  8320.,  7216.,  7632.,  8048.,  8464.,  7336.,
      7760.,  8184.,  8608.,  7696.,  8144.,  8592.,  9040.,  7816.,  8272.,
      8728.,  9184.,  7936.,  8400.,  8864.,  9328.,  8056.,  8528.,  9000.,
      9472.,  8176.,  8656.,  9136.,  9616.,  8296.,  8784.,  9272.,  9760.,
      8416.,  8912.,  9408.,  9904.,  8536.,  9040.,  9544.,  10048., 8656.,
      9168.,  9680.,  10192., 8776.,  9296.,  9816.,  10336., 9136.,  9680.,
      10224., 10768., 9256.,  9808.,  10360., 10912., 9376.,  9936.,  10496.,
      11056., 9496.,  10064., 10632., 11200., 9616.,  10192., 10768., 11344.,
      9736.,  10320., 10904., 11488., 9856.,  10448., 11040., 11632., 9976.,
      10576., 11176., 11776., 10096., 10704., 11312., 11920., 10216., 10832.,
      11448., 12064.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60852.,  61608.,  62364.,  63120.,  77010.,  77940.,  78870.,  79800.,
      93498.,  94596.,  95694.,  96792.,  78540.,  79440.,  80340.,  81240.,
      63300.,  64008.,  64716.,  65424.,  79310.,  80108.,  80906.,  81704.,
      99820.,  100800., 101780., 102760., 120547., 121702., 122857., 124012.,
      100765., 101710., 102655., 103600., 80822.,  81564.,  82306.,  83048.,
      98608.,  99424.,  100240., 101056., 123560., 124560., 125560., 126560.,
      148568., 149744., 150920., 152096., 123680., 124640., 125600., 126560.,
      98800.,  99552.,  100304., 101056., 81158.,  81788.,  82418.,  83048.,
      101290., 102060., 102830., 103600., 121303., 122206., 123109., 124012.,
      100555., 101290., 102025., 102760., 79982.,  80556.,  81130.,  81704.,
      64020.,  64488.,  64956.,  65424.,  79530.,  80100.,  80670.,  81240.,
      94794.,  95460.,  96126.,  96792.,  78180.,  78720.,  79260.,  79800.,
      61860.,  62280.,  62700.,  63120.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1892., 1928., 1964., 2000., 2036., 2072., 2108., 2144., 2180., 2216.,
      2252., 2288., 2324., 2360., 2396., 2432., 2468., 2504., 2540., 2576.,
      2756., 2792., 2828., 2864., 2900., 2936., 2972., 3008., 3044., 3080.,
      3116., 3152., 3188., 3224., 3260., 3296., 3332., 3368., 3404., 3440.,
      3620., 3656., 3692., 3728., 3764., 3800., 3836., 3872., 3908., 3944.,
      3980., 4016., 4052., 4088., 4124., 4160., 4196., 4232., 4268., 4304.,
      4484., 4520., 4556., 4592., 4628., 4664., 4700., 4736., 4772., 4808.,
      4844., 4880., 4916., 4952., 4988., 5024., 5060., 5096., 5132., 5168.,
      5348., 5384., 5420., 5456., 5492., 5528., 5564., 5600., 5636., 5672.,
      5708., 5744., 5780., 5816., 5852., 5888., 5924., 5960., 5996., 6032.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120096., 121704., 121584., 123216., 123072., 124728., 124560., 126240.,
      151950., 154020., 153780., 155880., 155610., 157740., 157440., 159600.,
      184440., 186996., 186600., 189192., 188760., 191388., 190920., 193584.,
      154890., 157080., 156660., 158880., 158430., 160680., 160200., 162480.,
      124800., 126600., 126192., 128016., 127584., 129432., 128976., 130848.,
      156408., 158620., 157976., 160216., 159544., 161812., 161112., 163408.,
      196805., 199640., 198730., 201600., 200655., 203560., 202580., 205520.,
      237608., 241094., 239876., 243404., 242144., 245714., 244412., 248024.,
      198555., 201530., 200410., 203420., 202265., 205310., 204120., 207200.,
      159208., 161644., 160664., 163128., 162120., 164612., 163576., 166096.,
      194304., 197216., 195904., 198848., 197504., 200480., 199104., 202112.,
      243400., 247120., 245360., 249120., 247320., 251120., 249280., 253120.,
      292576., 297136., 294880., 299488., 297184., 301840., 299488., 304192.,
      243480., 247360., 245360., 249280., 247240., 251200., 249120., 253120.,
      194432., 197600., 195904., 199104., 197376., 200608., 198848., 202112.,
      159432., 162316., 160664., 163576., 161896., 164836., 163128., 166096.,
      198905., 202580., 200410., 204120., 201915., 205660., 203420., 207200.,
      238112., 242606., 239876., 244412., 241640., 246218., 243404., 248024.,
      197295., 201110., 198730., 202580., 200165., 204050., 201600., 205520.,
      156856., 159964., 157976., 161112., 159096., 162260., 160216., 163408.,
      125280., 128040., 126192., 128976., 127104., 129912., 128016., 130848.,
      155550., 159060., 156660., 160200., 157770., 161340., 158880., 162480.,
      185304., 189588., 186600., 190920., 187896., 192252., 189192., 193584.,
      152730., 156360., 153780., 157440., 154830., 158520., 155880., 159600.,
      120768., 123720., 121584., 124560., 122400., 125400., 123216., 126240.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3472.,  3784.,  3536.,  3856.,  3600.,  3928.,  3664.,  4000.,  3728.,
      4072.,  3792.,  4144.,  3856.,  4216.,  3920.,  4288.,  3984.,  4360.,
      4048.,  4432.,  4112.,  4504.,  4176.,  4576.,  4240.,  4648.,  4304.,
      4720.,  4368.,  4792.,  4432.,  4864.,  4496.,  4936.,  4560.,  5008.,
      4624.,  5080.,  4688.,  5152.,  5008.,  5512.,  5072.,  5584.,  5136.,
      5656.,  5200.,  5728.,  5264.,  5800.,  5328.,  5872.,  5392.,  5944.,
      5456.,  6016.,  5520.,  6088.,  5584.,  6160.,  5648.,  6232.,  5712.,
      6304.,  5776.,  6376.,  5840.,  6448.,  5904.,  6520.,  5968.,  6592.,
      6032.,  6664.,  6096.,  6736.,  6160.,  6808.,  6224.,  6880.,  6544.,
      7240.,  6608.,  7312.,  6672.,  7384.,  6736.,  7456.,  6800.,  7528.,
      6864.,  7600.,  6928.,  7672.,  6992.,  7744.,  7056.,  7816.,  7120.,
      7888.,  7184.,  7960.,  7248.,  8032.,  7312.,  8104.,  7376.,  8176.,
      7440.,  8248.,  7504.,  8320.,  7568.,  8392.,  7632.,  8464.,  7696.,
      8536.,  7760.,  8608.,  8080.,  8968.,  8144.,  9040.,  8208.,  9112.,
      8272.,  9184.,  8336.,  9256.,  8400.,  9328.,  8464.,  9400.,  8528.,
      9472.,  8592.,  9544.,  8656.,  9616.,  8720.,  9688.,  8784.,  9760.,
      8848.,  9832.,  8912.,  9904.,  8976.,  9976.,  9040.,  10048., 9104.,
      10120., 9168.,  10192., 9232.,  10264., 9296.,  10336., 9616.,  10696.,
      9680.,  10768., 9744.,  10840., 9808.,  10912., 9872.,  10984., 9936.,
      11056., 10000., 11128., 10064., 11200., 10128., 11272., 10192., 11344.,
      10256., 11416., 10320., 11488., 10384., 11560., 10448., 11632., 10512.,
      11704., 10576., 11776., 10640., 11848., 10704., 11920., 10768., 11992.,
      10832., 12064.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      238584., 240192., 241800., 243408., 241536., 243168., 244800., 246432.,
      244488., 246144., 247800., 249456., 247440., 249120., 250800., 252480.,
      301830., 303900., 305970., 308040., 305460., 307560., 309660., 311760.,
      309090., 311220., 313350., 315480., 312720., 314880., 317040., 319200.,
      366324., 368880., 371436., 373992., 370608., 373200., 375792., 378384.,
      374892., 377520., 380148., 382776., 379176., 381840., 384504., 387168.,
      307590., 309780., 311970., 314160., 311100., 313320., 315540., 317760.,
      314610., 316860., 319110., 321360., 318120., 320400., 322680., 324960.,
      247800., 249600., 251400., 253200., 250560., 252384., 254208., 256032.,
      253320., 255168., 257016., 258864., 256080., 257952., 259824., 261696.,
      310604., 312816., 315028., 317240., 313712., 315952., 318192., 320432.,
      316820., 319088., 321356., 323624., 319928., 322224., 324520., 326816.,
      390775., 393610., 396445., 399280., 394590., 397460., 400330., 403200.,
      398405., 401310., 404215., 407120., 402220., 405160., 408100., 411040.,
      471730., 475216., 478702., 482188., 476224., 479752., 483280., 486808.,
      480718., 484288., 487858., 491428., 485212., 488824., 492436., 496048.,
      394135., 397110., 400085., 403060., 397810., 400820., 403830., 406840.,
      401485., 404530., 407575., 410620., 405160., 408240., 411320., 414400.,
      315980., 318416., 320852., 323288., 318864., 321328., 323792., 326256.,
      321748., 324240., 326732., 329224., 324632., 327152., 329672., 332192.,
      385696., 388608., 391520., 394432., 388864., 391808., 394752., 397696.,
      392032., 395008., 397984., 400960., 395200., 398208., 401216., 404224.,
      483080., 486800., 490520., 494240., 486960., 490720., 494480., 498240.,
      490840., 494640., 498440., 502240., 494720., 498560., 502400., 506240.,
      580592., 585152., 589712., 594272., 585152., 589760., 594368., 598976.,
      589712., 594368., 599024., 603680., 594272., 598976., 603680., 608384.,
      483080., 486960., 490840., 494720., 486800., 490720., 494640., 498560.,
      490520., 494480., 498440., 502400., 494240., 498240., 502240., 506240.,
      385696., 388864., 392032., 395200., 388608., 391808., 395008., 398208.,
      391520., 394752., 397984., 401216., 394432., 397696., 400960., 404224.,
      315980., 318864., 321748., 324632., 318416., 321328., 324240., 327152.,
      320852., 323792., 326732., 329672., 323288., 326256., 329224., 332192.,
      394135., 397810., 401485., 405160., 397110., 400820., 404530., 408240.,
      400085., 403830., 407575., 411320., 403060., 406840., 410620., 414400.,
      471730., 476224., 480718., 485212., 475216., 479752., 484288., 488824.,
      478702., 483280., 487858., 492436., 482188., 486808., 491428., 496048.,
      390775., 394590., 398405., 402220., 393610., 397460., 401310., 405160.,
      396445., 400330., 404215., 408100., 399280., 403200., 407120., 411040.,
      310604., 313712., 316820., 319928., 312816., 315952., 319088., 322224.,
      315028., 318192., 321356., 324520., 317240., 320432., 323624., 326816.,
      247800., 250560., 253320., 256080., 249600., 252384., 255168., 257952.,
      251400., 254208., 257016., 259824., 253200., 256032., 258864., 261696.,
      307590., 311100., 314610., 318120., 309780., 313320., 316860., 320400.,
      311970., 315540., 319110., 322680., 314160., 317760., 321360., 324960.,
      366324., 370608., 374892., 379176., 368880., 373200., 377520., 381840.,
      371436., 375792., 380148., 384504., 373992., 378384., 382776., 387168.,
      301830., 305460., 309090., 312720., 303900., 307560., 311220., 314880.,
      305970., 309660., 313350., 317040., 308040., 311760., 315480., 319200.,
      238584., 241536., 244488., 247440., 240192., 243168., 246144., 249120.,
      241800., 244800., 247800., 250800., 243408., 246432., 249456., 252480.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6632.,  6944.,  7256.,  7568.,  6752.,  7072.,  7392.,  7712.,  6872.,
      7200.,  7528.,  7856.,  6992.,  7328.,  7664.,  8000.,  7112.,  7456.,
      7800.,  8144.,  7232.,  7584.,  7936.,  8288.,  7352.,  7712.,  8072.,
      8432.,  7472.,  7840.,  8208.,  8576.,  7592.,  7968.,  8344.,  8720.,
      7712.,  8096.,  8480.,  8864.,  7832.,  8224.,  8616.,  9008.,  7952.,
      8352.,  8752.,  9152.,  8072.,  8480.,  8888.,  9296.,  8192.,  8608.,
      9024.,  9440.,  8312.,  8736.,  9160.,  9584.,  8432.,  8864.,  9296.,
      9728.,  8552.,  8992.,  9432.,  9872.,  8672.,  9120.,  9568.,  10016.,
      8792.,  9248.,  9704.,  10160., 8912.,  9376.,  9840.,  10304., 9512.,
      10016., 10520., 11024., 9632.,  10144., 10656., 11168., 9752.,  10272.,
      10792., 11312., 9872.,  10400., 10928., 11456., 9992.,  10528., 11064.,
      11600., 10112., 10656., 11200., 11744., 10232., 10784., 11336., 11888.,
      10352., 10912., 11472., 12032., 10472., 11040., 11608., 12176., 10592.,
      11168., 11744., 12320., 10712., 11296., 11880., 12464., 10832., 11424.,
      12016., 12608., 10952., 11552., 12152., 12752., 11072., 11680., 12288.,
      12896., 11192., 11808., 12424., 13040., 11312., 11936., 12560., 13184.,
      11432., 12064., 12696., 13328., 11552., 12192., 12832., 13472., 11672.,
      12320., 12968., 13616., 11792., 12448., 13104., 13760., 12392., 13088.,
      13784., 14480., 12512., 13216., 13920., 14624., 12632., 13344., 14056.,
      14768., 12752., 13472., 14192., 14912., 12872., 13600., 14328., 15056.,
      12992., 13728., 14464., 15200., 13112., 13856., 14600., 15344., 13232.,
      13984., 14736., 15488., 13352., 14112., 14872., 15632., 13472., 14240.,
      15008., 15776., 13592., 14368., 15144., 15920., 13712., 14496., 15280.,
      16064., 13832., 14624., 15416., 16208., 13952., 14752., 15552., 16352.,
      14072., 14880., 15688., 16496., 14192., 15008., 15824., 16640., 14312.,
      15136., 15960., 16784., 14432., 15264., 16096., 16928., 14552., 15392.,
      16232., 17072., 14672., 15520., 16368., 17216., 15272., 16160., 17048.,
      17936., 15392., 16288., 17184., 18080., 15512., 16416., 17320., 18224.,
      15632., 16544., 17456., 18368., 15752., 16672., 17592., 18512., 15872.,
      16800., 17728., 18656., 15992., 16928., 17864., 18800., 16112., 17056.,
      18000., 18944., 16232., 17184., 18136., 19088., 16352., 17312., 18272.,
      19232., 16472., 17440., 18408., 19376., 16592., 17568., 18544., 19520.,
      16712., 17696., 18680., 19664., 16832., 17824., 18816., 19808., 16952.,
      17952., 18952., 19952., 17072., 18080., 19088., 20096., 17192., 18208.,
      19224., 20240., 17312., 18336., 19360., 20384., 17432., 18464., 19496.,
      20528., 17552., 18592., 19632., 20672., 18152., 19232., 20312., 21392.,
      18272., 19360., 20448., 21536., 18392., 19488., 20584., 21680., 18512.,
      19616., 20720., 21824., 18632., 19744., 20856., 21968., 18752., 19872.,
      20992., 22112., 18872., 20000., 21128., 22256., 18992., 20128., 21264.,
      22400., 19112., 20256., 21400., 22544., 19232., 20384., 21536., 22688.,
      19352., 20512., 21672., 22832., 19472., 20640., 21808., 22976., 19592.,
      20768., 21944., 23120., 19712., 20896., 22080., 23264., 19832., 21024.,
      22216., 23408., 19952., 21152., 22352., 23552., 20072., 21280., 22488.,
      23696., 20192., 21408., 22624., 23840., 20312., 21536., 22760., 23984.,
      20432., 21664., 22896., 24128.};
  const std::array<int, 4> in_shape = {{1, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      26795., 32466., 38227., 32970., 27635., 34650., 41797., 49000., 42091.,
      35140., 42820., 51464., 60116., 51464., 42820., 35140., 42091., 49000.,
      41797., 34650., 27635., 32970., 38227., 32466., 26795.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1298., 1376., 1454., 1532., 1610., 1844., 1922., 2000., 2078.,
      2156., 2390., 2468., 2546., 2624., 2702., 2936., 3014., 3092.,
      3170., 3248., 3482., 3560., 3638., 3716., 3794.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52975.,  53590.,  64176.,  64932.,  75551., 76454., 65148.,  65940.,
      54595.,  55270.,  68460.,  69300.,  82565., 83594., 96775.,  98000.,
      83111.,  84182.,  69370.,  70280.,  84540., 85640., 101584., 102928.,
      118636., 120232., 101536., 102928., 84460., 85640., 69195.,  70280.,
      82859.,  84182.,  96432.,  98000.,  82229., 83594., 68145.,  69300.,
      54235.,  55270.,  64680.,  65940.,  74963., 76454., 63636.,  64932.,
      52495.,  53590.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2446., 2596., 2590., 2752., 2734., 2908., 2878., 3064., 3022., 3220.,
      3454., 3688., 3598., 3844., 3742., 4000., 3886., 4156., 4030., 4312.,
      4462., 4780., 4606., 4936., 4750., 5092., 4894., 5248., 5038., 5404.,
      5470., 5872., 5614., 6028., 5758., 6184., 5902., 6340., 6046., 6496.,
      6478., 6964., 6622., 7120., 6766., 7276., 6910., 7432., 7054., 7588.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      105335., 105950., 106565., 107180., 127596., 128352., 129108., 129864.,
      150199., 151102., 152005., 152908., 129504., 130296., 131088., 131880.,
      108515., 109190., 109865., 110540., 136080., 136920., 137760., 138600.,
      164101., 165130., 166159., 167188., 192325., 193550., 194775., 196000.,
      165151., 166222., 167293., 168364., 137830., 138740., 139650., 140560.,
      167980., 169080., 170180., 171280., 201824., 203168., 204512., 205856.,
      235676., 237272., 238868., 240464., 201680., 203072., 204464., 205856.,
      167740., 168920., 170100., 171280., 137305., 138390., 139475., 140560.,
      164395., 165718., 167041., 168364., 191296., 192864., 194432., 196000.,
      163093., 164458., 165823., 167188., 135135., 136290., 137445., 138600.,
      107435., 108470., 109505., 110540., 128100., 129360., 130620., 131880.,
      148435., 149926., 151417., 152908., 125976., 127272., 128568., 129864.,
      103895., 104990., 106085., 107180.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4742.,  4892.,  5042.,  5192.,  5018.,  5180.,  5342.,  5504.,  5294.,
      5468.,  5642.,  5816.,  5570.,  5756.,  5942.,  6128.,  5846.,  6044.,
      6242.,  6440.,  6674.,  6908.,  7142.,  7376.,  6950.,  7196.,  7442.,
      7688.,  7226.,  7484.,  7742.,  8000.,  7502.,  7772.,  8042.,  8312.,
      7778.,  8060.,  8342.,  8624.,  8606.,  8924.,  9242.,  9560.,  8882.,
      9212.,  9542.,  9872.,  9158.,  9500.,  9842.,  10184., 9434.,  9788.,
      10142., 10496., 9710.,  10076., 10442., 10808., 10538., 10940., 11342.,
      11744., 10814., 11228., 11642., 12056., 11090., 11516., 11942., 12368.,
      11366., 11804., 12242., 12680., 11642., 12092., 12542., 12992., 12470.,
      12956., 13442., 13928., 12746., 13244., 13742., 14240., 13022., 13532.,
      14042., 14552., 13298., 13820., 14342., 14864., 13574., 14108., 14642.,
      15176.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      52495.,  53590.,  63636.,  64932.,  74963., 76454., 64680.,  65940.,
      54235.,  55270.,  68145.,  69300.,  82229., 83594., 96432.,  98000.,
      82859.,  84182.,  69195.,  70280.,  84460., 85640., 101536., 102928.,
      118636., 120232., 101584., 102928., 84540., 85640., 69370.,  70280.,
      83111.,  84182.,  96775.,  98000.,  82565., 83594., 68460.,  69300.,
      54595.,  55270.,  65148.,  65940.,  75551., 76454., 64176.,  64932.,
      52975.,  53590.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2518., 2596., 2674., 2752., 2830., 2908., 2986., 3064., 3142., 3220.,
      3610., 3688., 3766., 3844., 3922., 4000., 4078., 4156., 4234., 4312.,
      4702., 4780., 4858., 4936., 5014., 5092., 5170., 5248., 5326., 5404.,
      5794., 5872., 5950., 6028., 6106., 6184., 6262., 6340., 6418., 6496.,
      6886., 6964., 7042., 7120., 7198., 7276., 7354., 7432., 7510., 7588.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      103790., 104990., 105950., 107180., 125796., 127272., 128352., 129864.,
      148162., 149926., 151102., 152908., 127812., 129360., 130296., 131880.,
      107150., 108470., 109190., 110540., 134645., 136290., 136920., 138600.,
      162442., 164458., 165130., 167188., 190463., 192864., 193550., 196000.,
      163618., 165718., 166222., 168364., 136605., 138390., 138740., 140560.,
      166760., 168920., 169080., 171280., 200432., 203072., 203168., 205856.,
      234136., 237272., 237272., 240464., 200432., 203168., 203072., 205856.,
      166760., 169080., 168920., 171280., 136605., 138740., 138390., 140560.,
      163618., 166222., 165718., 168364., 190463., 193550., 192864., 196000.,
      162442., 165130., 164458., 167188., 134645., 136920., 136290., 138600.,
      107150., 109190., 108470., 110540., 127812., 130296., 129360., 131880.,
      148162., 151102., 149926., 152908., 125796., 128352., 127272., 129864.,
      103790., 105950., 104990., 107180.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4748.,  5036.,  4892.,  5192.,  5036.,  5348.,  5180.,  5504.,  5324.,
      5660.,  5468.,  5816.,  5612.,  5972.,  5756.,  6128.,  5900.,  6284.,
      6044.,  6440.,  6764.,  7220.,  6908.,  7376.,  7052.,  7532.,  7196.,
      7688.,  7340.,  7844.,  7484.,  8000.,  7628.,  8156.,  7772.,  8312.,
      7916.,  8468.,  8060.,  8624.,  8780.,  9404.,  8924.,  9560.,  9068.,
      9716.,  9212.,  9872.,  9356.,  10028., 9500.,  10184., 9644.,  10340.,
      9788.,  10496., 9932.,  10652., 10076., 10808., 10796., 11588., 10940.,
      11744., 11084., 11900., 11228., 12056., 11372., 12212., 11516., 12368.,
      11660., 12524., 11804., 12680., 11948., 12836., 12092., 12992., 12812.,
      13772., 12956., 13928., 13100., 14084., 13244., 14240., 13388., 14396.,
      13532., 14552., 13676., 14708., 13820., 14864., 13964., 15020., 14108.,
      15176.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      206380., 207580., 208780., 209980., 210670., 211900., 213130., 214360.,
      250116., 251592., 253068., 254544., 255192., 256704., 258216., 259728.,
      294560., 296324., 298088., 299852., 300398., 302204., 304010., 305816.,
      254076., 255624., 257172., 258720., 259008., 260592., 262176., 263760.,
      212980., 214300., 215620., 216940., 217030., 218380., 219730., 221080.,
      267645., 269290., 270935., 272580., 272160., 273840., 275520., 277200.,
      322868., 324884., 326900., 328916., 328202., 330260., 332318., 334376.,
      378525., 380926., 383327., 385728., 384650., 387100., 389550., 392000.,
      325136., 327236., 329336., 331436., 330302., 332444., 334586., 336728.,
      271425., 273210., 274995., 276780., 275660., 277480., 279300., 281120.,
      331360., 333520., 335680., 337840., 335960., 338160., 340360., 342560.,
      398224., 400864., 403504., 406144., 403648., 406336., 409024., 411712.,
      465136., 468272., 471408., 474544., 471352., 474544., 477736., 480928.,
      398128., 400864., 403600., 406336., 403360., 406144., 408928., 411712.,
      331200., 333520., 335840., 338160., 335480., 337840., 340200., 342560.,
      271075., 273210., 275345., 277480., 274610., 276780., 278950., 281120.,
      324632., 327236., 329840., 332444., 328790., 331436., 334082., 336728.,
      377839., 380926., 384013., 387100., 382592., 385728., 388864., 392000.,
      322196., 324884., 327572., 330260., 326186., 328916., 331646., 334376.,
      267015., 269290., 271565., 273840., 270270., 272580., 274890., 277200.,
      212260., 214300., 216340., 218380., 214870., 216940., 219010., 221080.,
      253140., 255624., 258108., 260592., 256200., 258720., 261240., 263760.,
      293384., 296324., 299264., 302204., 296870., 299852., 302834., 305816.,
      249036., 251592., 254148., 256704., 251952., 254544., 257136., 259728.,
      205420., 207580., 209740., 211900., 207790., 209980., 212170., 214360.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9208.,  9496.,  9784.,  10072., 9484.,  9784.,  10084., 10384., 9760.,
      10072., 10384., 10696., 10036., 10360., 10684., 11008., 10312., 10648.,
      10984., 11320., 10588., 10936., 11284., 11632., 10864., 11224., 11584.,
      11944., 11140., 11512., 11884., 12256., 11416., 11800., 12184., 12568.,
      11692., 12088., 12484., 12880., 13072., 13528., 13984., 14440., 13348.,
      13816., 14284., 14752., 13624., 14104., 14584., 15064., 13900., 14392.,
      14884., 15376., 14176., 14680., 15184., 15688., 14452., 14968., 15484.,
      16000., 14728., 15256., 15784., 16312., 15004., 15544., 16084., 16624.,
      15280., 15832., 16384., 16936., 15556., 16120., 16684., 17248., 16936.,
      17560., 18184., 18808., 17212., 17848., 18484., 19120., 17488., 18136.,
      18784., 19432., 17764., 18424., 19084., 19744., 18040., 18712., 19384.,
      20056., 18316., 19000., 19684., 20368., 18592., 19288., 19984., 20680.,
      18868., 19576., 20284., 20992., 19144., 19864., 20584., 21304., 19420.,
      20152., 20884., 21616., 20800., 21592., 22384., 23176., 21076., 21880.,
      22684., 23488., 21352., 22168., 22984., 23800., 21628., 22456., 23284.,
      24112., 21904., 22744., 23584., 24424., 22180., 23032., 23884., 24736.,
      22456., 23320., 24184., 25048., 22732., 23608., 24484., 25360., 23008.,
      23896., 24784., 25672., 23284., 24184., 25084., 25984., 24664., 25624.,
      26584., 27544., 24940., 25912., 26884., 27856., 25216., 26200., 27184.,
      28168., 25492., 26488., 27484., 28480., 25768., 26776., 27784., 28792.,
      26044., 27064., 28084., 29104., 26320., 27352., 28384., 29416., 26596.,
      27640., 28684., 29728., 26872., 27928., 28984., 30040., 27148., 28216.,
      29284., 30352.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      103895., 104990., 106085., 107180., 125976., 127272., 128568., 129864.,
      148435., 149926., 151417., 152908., 128100., 129360., 130620., 131880.,
      107435., 108470., 109505., 110540., 135135., 136290., 137445., 138600.,
      163093., 164458., 165823., 167188., 191296., 192864., 194432., 196000.,
      164395., 165718., 167041., 168364., 137305., 138390., 139475., 140560.,
      167740., 168920., 170100., 171280., 201680., 203072., 204464., 205856.,
      235676., 237272., 238868., 240464., 201824., 203168., 204512., 205856.,
      167980., 169080., 170180., 171280., 137830., 138740., 139650., 140560.,
      165151., 166222., 167293., 168364., 192325., 193550., 194775., 196000.,
      164101., 165130., 166159., 167188., 136080., 136920., 137760., 138600.,
      108515., 109190., 109865., 110540., 129504., 130296., 131088., 131880.,
      150199., 151102., 152005., 152908., 127596., 128352., 129108., 129864.,
      105335., 105950., 106565., 107180.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4958.,  5036.,  5114.,  5192.,  5270.,  5348.,  5426.,  5504.,  5582.,
      5660.,  5738.,  5816.,  5894.,  5972.,  6050.,  6128.,  6206.,  6284.,
      6362.,  6440.,  7142.,  7220.,  7298.,  7376.,  7454.,  7532.,  7610.,
      7688.,  7766.,  7844.,  7922.,  8000.,  8078.,  8156.,  8234.,  8312.,
      8390.,  8468.,  8546.,  8624.,  9326.,  9404.,  9482.,  9560.,  9638.,
      9716.,  9794.,  9872.,  9950.,  10028., 10106., 10184., 10262., 10340.,
      10418., 10496., 10574., 10652., 10730., 10808., 11510., 11588., 11666.,
      11744., 11822., 11900., 11978., 12056., 12134., 12212., 12290., 12368.,
      12446., 12524., 12602., 12680., 12758., 12836., 12914., 12992., 13694.,
      13772., 13850., 13928., 14006., 14084., 14162., 14240., 14318., 14396.,
      14474., 14552., 14630., 14708., 14786., 14864., 14942., 15020., 15098.,
      15176.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      205420., 207790., 207580., 209980., 209740., 212170., 211900., 214360.,
      249036., 251952., 251592., 254544., 254148., 257136., 256704., 259728.,
      293384., 296870., 296324., 299852., 299264., 302834., 302204., 305816.,
      253140., 256200., 255624., 258720., 258108., 261240., 260592., 263760.,
      212260., 214870., 214300., 216940., 216340., 219010., 218380., 221080.,
      267015., 270270., 269290., 272580., 271565., 274890., 273840., 277200.,
      322196., 326186., 324884., 328916., 327572., 331646., 330260., 334376.,
      377839., 382592., 380926., 385728., 384013., 388864., 387100., 392000.,
      324632., 328790., 327236., 331436., 329840., 334082., 332444., 336728.,
      271075., 274610., 273210., 276780., 275345., 278950., 277480., 281120.,
      331200., 335480., 333520., 337840., 335840., 340200., 338160., 342560.,
      398128., 403360., 400864., 406144., 403600., 408928., 406336., 411712.,
      465136., 471352., 468272., 474544., 471408., 477736., 474544., 480928.,
      398224., 403648., 400864., 406336., 403504., 409024., 406144., 411712.,
      331360., 335960., 333520., 338160., 335680., 340360., 337840., 342560.,
      271425., 275660., 273210., 277480., 274995., 279300., 276780., 281120.,
      325136., 330302., 327236., 332444., 329336., 334586., 331436., 336728.,
      378525., 384650., 380926., 387100., 383327., 389550., 385728., 392000.,
      322868., 328202., 324884., 330260., 326900., 332318., 328916., 334376.,
      267645., 272160., 269290., 273840., 270935., 275520., 272580., 277200.,
      212980., 217030., 214300., 218380., 215620., 219730., 216940., 221080.,
      254076., 259008., 255624., 260592., 257172., 262176., 258720., 263760.,
      294560., 300398., 296324., 302204., 298088., 304010., 299852., 305816.,
      250116., 255192., 251592., 256704., 253068., 258216., 254544., 259728.,
      206380., 210670., 207580., 211900., 208780., 213130., 209980., 214360.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9352.,  9916.,  9496.,  10072., 9640.,  10228., 9784.,  10384., 9928.,
      10540., 10072., 10696., 10216., 10852., 10360., 11008., 10504., 11164.,
      10648., 11320., 10792., 11476., 10936., 11632., 11080., 11788., 11224.,
      11944., 11368., 12100., 11512., 12256., 11656., 12412., 11800., 12568.,
      11944., 12724., 12088., 12880., 13384., 14284., 13528., 14440., 13672.,
      14596., 13816., 14752., 13960., 14908., 14104., 15064., 14248., 15220.,
      14392., 15376., 14536., 15532., 14680., 15688., 14824., 15844., 14968.,
      16000., 15112., 16156., 15256., 16312., 15400., 16468., 15544., 16624.,
      15688., 16780., 15832., 16936., 15976., 17092., 16120., 17248., 17416.,
      18652., 17560., 18808., 17704., 18964., 17848., 19120., 17992., 19276.,
      18136., 19432., 18280., 19588., 18424., 19744., 18568., 19900., 18712.,
      20056., 18856., 20212., 19000., 20368., 19144., 20524., 19288., 20680.,
      19432., 20836., 19576., 20992., 19720., 21148., 19864., 21304., 20008.,
      21460., 20152., 21616., 21448., 23020., 21592., 23176., 21736., 23332.,
      21880., 23488., 22024., 23644., 22168., 23800., 22312., 23956., 22456.,
      24112., 22600., 24268., 22744., 24424., 22888., 24580., 23032., 24736.,
      23176., 24892., 23320., 25048., 23464., 25204., 23608., 25360., 23752.,
      25516., 23896., 25672., 24040., 25828., 24184., 25984., 25480., 27388.,
      25624., 27544., 25768., 27700., 25912., 27856., 26056., 28012., 26200.,
      28168., 26344., 28324., 26488., 28480., 26632., 28636., 26776., 28792.,
      26920., 28948., 27064., 29104., 27208., 29260., 27352., 29416., 27496.,
      29572., 27640., 29728., 27784., 29884., 27928., 30040., 28072., 30196.,
      28216., 30352.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      408470., 410840., 413210., 415580., 412760., 415160., 417560., 419960.,
      417050., 419480., 421910., 424340., 421340., 423800., 426260., 428720.,
      495156., 498072., 500988., 503904., 500232., 503184., 506136., 509088.,
      505308., 508296., 511284., 514272., 510384., 513408., 516432., 519456.,
      583282., 586768., 590254., 593740., 589120., 592648., 596176., 599704.,
      594958., 598528., 602098., 605668., 600796., 604408., 608020., 611632.,
      503220., 506280., 509340., 512400., 508152., 511248., 514344., 517440.,
      513084., 516216., 519348., 522480., 518016., 521184., 524352., 527520.,
      421910., 424520., 427130., 429740., 425960., 428600., 431240., 433880.,
      430010., 432680., 435350., 438020., 434060., 436760., 439460., 442160.,
      530775., 534030., 537285., 540540., 535290., 538580., 541870., 545160.,
      539805., 543130., 546455., 549780., 544320., 547680., 551040., 554400.,
      640402., 644392., 648382., 652372., 645736., 649768., 653800., 657832.,
      651070., 655144., 659218., 663292., 656404., 660520., 664636., 668752.,
      750925., 755678., 760431., 765184., 757050., 761852., 766654., 771456.,
      763175., 768026., 772877., 777728., 769300., 774200., 779100., 784000.,
      645106., 649264., 653422., 657580., 650272., 654472., 658672., 662872.,
      655438., 659680., 663922., 668164., 660604., 664888., 669172., 673456.,
      538615., 542150., 545685., 549220., 542850., 546420., 549990., 553560.,
      547085., 550690., 554295., 557900., 551320., 554960., 558600., 562240.,
      658120., 662400., 666680., 670960., 662720., 667040., 671360., 675680.,
      667320., 671680., 676040., 680400., 671920., 676320., 680720., 685120.,
      791024., 796256., 801488., 806720., 796448., 801728., 807008., 812288.,
      801872., 807200., 812528., 817856., 807296., 812672., 818048., 823424.,
      924056., 930272., 936488., 942704., 930272., 936544., 942816., 949088.,
      936488., 942816., 949144., 955472., 942704., 949088., 955472., 961856.,
      791024., 796448., 801872., 807296., 796256., 801728., 807200., 812672.,
      801488., 807008., 812528., 818048., 806720., 812288., 817856., 823424.,
      658120., 662720., 667320., 671920., 662400., 667040., 671680., 676320.,
      666680., 671360., 676040., 680720., 670960., 675680., 680400., 685120.,
      538615., 542850., 547085., 551320., 542150., 546420., 550690., 554960.,
      545685., 549990., 554295., 558600., 549220., 553560., 557900., 562240.,
      645106., 650272., 655438., 660604., 649264., 654472., 659680., 664888.,
      653422., 658672., 663922., 669172., 657580., 662872., 668164., 673456.,
      750925., 757050., 763175., 769300., 755678., 761852., 768026., 774200.,
      760431., 766654., 772877., 779100., 765184., 771456., 777728., 784000.,
      640402., 645736., 651070., 656404., 644392., 649768., 655144., 660520.,
      648382., 653800., 659218., 664636., 652372., 657832., 663292., 668752.,
      530775., 535290., 539805., 544320., 534030., 538580., 543130., 547680.,
      537285., 541870., 546455., 551040., 540540., 545160., 549780., 554400.,
      421910., 425960., 430010., 434060., 424520., 428600., 432680., 436760.,
      427130., 431240., 435350., 439460., 429740., 433880., 438020., 442160.,
      503220., 508152., 513084., 518016., 506280., 511248., 516216., 521184.,
      509340., 514344., 519348., 524352., 512400., 517440., 522480., 527520.,
      583282., 589120., 594958., 600796., 586768., 592648., 598528., 604408.,
      590254., 596176., 602098., 608020., 593740., 599704., 605668., 611632.,
      495156., 500232., 505308., 510384., 498072., 503184., 508296., 513408.,
      500988., 506136., 511284., 516432., 503904., 509088., 514272., 519456.,
      408470., 412760., 417050., 421340., 410840., 415160., 419480., 423800.,
      413210., 417560., 421910., 426260., 415580., 419960., 424340., 428720.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18140., 18704., 19268., 19832., 18416., 18992., 19568., 20144., 18692.,
      19280., 19868., 20456., 18968., 19568., 20168., 20768., 19244., 19856.,
      20468., 21080., 19520., 20144., 20768., 21392., 19796., 20432., 21068.,
      21704., 20072., 20720., 21368., 22016., 20348., 21008., 21668., 22328.,
      20624., 21296., 21968., 22640., 20900., 21584., 22268., 22952., 21176.,
      21872., 22568., 23264., 21452., 22160., 22868., 23576., 21728., 22448.,
      23168., 23888., 22004., 22736., 23468., 24200., 22280., 23024., 23768.,
      24512., 22556., 23312., 24068., 24824., 22832., 23600., 24368., 25136.,
      23108., 23888., 24668., 25448., 23384., 24176., 24968., 25760., 25868.,
      26768., 27668., 28568., 26144., 27056., 27968., 28880., 26420., 27344.,
      28268., 29192., 26696., 27632., 28568., 29504., 26972., 27920., 28868.,
      29816., 27248., 28208., 29168., 30128., 27524., 28496., 29468., 30440.,
      27800., 28784., 29768., 30752., 28076., 29072., 30068., 31064., 28352.,
      29360., 30368., 31376., 28628., 29648., 30668., 31688., 28904., 29936.,
      30968., 32000., 29180., 30224., 31268., 32312., 29456., 30512., 31568.,
      32624., 29732., 30800., 31868., 32936., 30008., 31088., 32168., 33248.,
      30284., 31376., 32468., 33560., 30560., 31664., 32768., 33872., 30836.,
      31952., 33068., 34184., 31112., 32240., 33368., 34496., 33596., 34832.,
      36068., 37304., 33872., 35120., 36368., 37616., 34148., 35408., 36668.,
      37928., 34424., 35696., 36968., 38240., 34700., 35984., 37268., 38552.,
      34976., 36272., 37568., 38864., 35252., 36560., 37868., 39176., 35528.,
      36848., 38168., 39488., 35804., 37136., 38468., 39800., 36080., 37424.,
      38768., 40112., 36356., 37712., 39068., 40424., 36632., 38000., 39368.,
      40736., 36908., 38288., 39668., 41048., 37184., 38576., 39968., 41360.,
      37460., 38864., 40268., 41672., 37736., 39152., 40568., 41984., 38012.,
      39440., 40868., 42296., 38288., 39728., 41168., 42608., 38564., 40016.,
      41468., 42920., 38840., 40304., 41768., 43232., 41324., 42896., 44468.,
      46040., 41600., 43184., 44768., 46352., 41876., 43472., 45068., 46664.,
      42152., 43760., 45368., 46976., 42428., 44048., 45668., 47288., 42704.,
      44336., 45968., 47600., 42980., 44624., 46268., 47912., 43256., 44912.,
      46568., 48224., 43532., 45200., 46868., 48536., 43808., 45488., 47168.,
      48848., 44084., 45776., 47468., 49160., 44360., 46064., 47768., 49472.,
      44636., 46352., 48068., 49784., 44912., 46640., 48368., 50096., 45188.,
      46928., 48668., 50408., 45464., 47216., 48968., 50720., 45740., 47504.,
      49268., 51032., 46016., 47792., 49568., 51344., 46292., 48080., 49868.,
      51656., 46568., 48368., 50168., 51968., 49052., 50960., 52868., 54776.,
      49328., 51248., 53168., 55088., 49604., 51536., 53468., 55400., 49880.,
      51824., 53768., 55712., 50156., 52112., 54068., 56024., 50432., 52400.,
      54368., 56336., 50708., 52688., 54668., 56648., 50984., 52976., 54968.,
      56960., 51260., 53264., 55268., 57272., 51536., 53552., 55568., 57584.,
      51812., 53840., 55868., 57896., 52088., 54128., 56168., 58208., 52364.,
      54416., 56468., 58520., 52640., 54704., 56768., 58832., 52916., 54992.,
      57068., 59144., 53192., 55280., 57368., 59456., 53468., 55568., 57668.,
      59768., 53744., 55856., 57968., 60080., 54020., 56144., 58268., 60392.,
      54296., 56432., 58568., 60704.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41934., 49336., 56840., 50008., 43086., 54187., 63504., 72884., 63896.,
      54859., 66920., 78176., 89440., 78176., 66920., 54859., 63896., 72884.,
      63504., 54187., 43086., 50008., 56840., 49336., 41934.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2632., 2768., 2904., 3040., 3176., 3720., 3856., 3992., 4128.,
      4264., 4808., 4944., 5080., 5216., 5352., 5896., 6032., 6168.,
      6304., 6440., 6984., 7120., 7256., 7392., 7528.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83022.,  83868.,  97664.,  98672.,  112504., 113680., 98966.,  100016.,
      85254.,  86172.,  107219., 108374., 125636., 127008., 144172., 145768.,
      126371., 127792., 108479., 109718., 132328., 133840., 154560., 156352.,
      176800., 178880., 154504., 156352., 132232., 133840., 108227., 109718.,
      126028., 127792., 143724., 145768., 125195., 127008., 106799., 108374.,
      84750.,  86172.,  98336.,  100016., 111736., 113680., 96950.,  98672.,
      82374.,  83868.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5032.,  5264.,  5288.,  5536.,  5544.,  5808.,  5800.,  6080.,  6056.,
      6352.,  7080.,  7440.,  7336.,  7712.,  7592.,  7984.,  7848.,  8256.,
      8104.,  8528.,  9128.,  9616.,  9384.,  9888.,  9640.,  10160., 9896.,
      10432., 10152., 10704., 11176., 11792., 11432., 12064., 11688., 12336.,
      11944., 12608., 12200., 12880., 13224., 13968., 13480., 14240., 13736.,
      14512., 13992., 14784., 14248., 15056.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      165198., 166044., 166890., 167736., 194320., 195328., 196336., 197344.,
      223832., 225008., 226184., 227360., 196882., 197932., 198982., 200032.,
      169590., 170508., 171426., 172344., 213283., 214438., 215593., 216748.,
      249900., 251272., 252644., 254016., 286748., 288344., 289940., 291536.,
      251321., 252742., 254163., 255584., 215719., 216958., 218197., 219436.,
      263144., 264656., 266168., 267680., 307328., 309120., 310912., 312704.,
      351520., 353600., 355680., 357760., 307160., 309008., 310856., 312704.,
      262856., 264464., 266072., 267680., 214963., 216454., 217945., 219436.,
      250292., 252056., 253820., 255584., 285404., 287448., 289492., 291536.,
      248577., 250390., 252203., 254016., 212023., 213598., 215173., 216748.,
      168078., 169500., 170922., 172344., 194992., 196672., 198352., 200032.,
      221528., 223472., 225416., 227360., 192178., 193900., 195622., 197344.,
      163254., 164748., 166242., 167736.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9832.,  10064., 10296., 10528., 10328., 10576., 10824., 11072., 10824.,
      11088., 11352., 11616., 11320., 11600., 11880., 12160., 11816., 12112.,
      12408., 12704., 13800., 14160., 14520., 14880., 14296., 14672., 15048.,
      15424., 14792., 15184., 15576., 15968., 15288., 15696., 16104., 16512.,
      15784., 16208., 16632., 17056., 17768., 18256., 18744., 19232., 18264.,
      18768., 19272., 19776., 18760., 19280., 19800., 20320., 19256., 19792.,
      20328., 20864., 19752., 20304., 20856., 21408., 21736., 22352., 22968.,
      23584., 22232., 22864., 23496., 24128., 22728., 23376., 24024., 24672.,
      23224., 23888., 24552., 25216., 23720., 24400., 25080., 25760., 25704.,
      26448., 27192., 27936., 26200., 26960., 27720., 28480., 26696., 27472.,
      28248., 29024., 27192., 27984., 28776., 29568., 27688., 28496., 29304.,
      30112.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      82374.,  83868.,  96950.,  98672.,  111736., 113680., 98336.,  100016.,
      84750.,  86172.,  106799., 108374., 125195., 127008., 143724., 145768.,
      126028., 127792., 108227., 109718., 132232., 133840., 154504., 156352.,
      176800., 178880., 154560., 156352., 132328., 133840., 108479., 109718.,
      126371., 127792., 144172., 145768., 125636., 127008., 107219., 108374.,
      85254.,  86172.,  98966.,  100016., 112504., 113680., 97664.,  98672.,
      83022.,  83868.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5128.,  5264.,  5400.,  5536.,  5672.,  5808.,  5944.,  6080.,  6216.,
      6352.,  7304.,  7440.,  7576.,  7712.,  7848.,  7984.,  8120.,  8256.,
      8392.,  8528.,  9480.,  9616.,  9752.,  9888.,  10024., 10160., 10296.,
      10432., 10568., 10704., 11656., 11792., 11928., 12064., 12200., 12336.,
      12472., 12608., 12744., 12880., 13832., 13968., 14104., 14240., 14376.,
      14512., 14648., 14784., 14920., 15056.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      163092., 164748., 166044., 167736., 191926., 193900., 195328., 197344.,
      221168., 223472., 225008., 227360., 194614., 196672., 197932., 200032.,
      167700., 169500., 170508., 172344., 211330., 213598., 214438., 216748.,
      247695., 250390., 251272., 254016., 284312., 287448., 288344., 291536.,
      249263., 252056., 252742., 255584., 214018., 216454., 216958., 219436.,
      261488., 264464., 264656., 267680., 305480., 309008., 309120., 312704.,
      349504., 353600., 353600., 357760., 305480., 309120., 309008., 312704.,
      261488., 264656., 264464., 267680., 214018., 216958., 216454., 219436.,
      249263., 252742., 252056., 255584., 284312., 288344., 287448., 291536.,
      247695., 251272., 250390., 254016., 211330., 214438., 213598., 216748.,
      167700., 170508., 169500., 172344., 194614., 197932., 196672., 200032.,
      221168., 225008., 223472., 227360., 191926., 195328., 193900., 197344.,
      163092., 166044., 164748., 167736.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9808.,  10256., 10064., 10528., 10320., 10800., 10576., 11072., 10832.,
      11344., 11088., 11616., 11344., 11888., 11600., 12160., 11856., 12432.,
      12112., 12704., 13904., 14608., 14160., 14880., 14416., 15152., 14672.,
      15424., 14928., 15696., 15184., 15968., 15440., 16240., 15696., 16512.,
      15952., 16784., 16208., 17056., 18000., 18960., 18256., 19232., 18512.,
      19504., 18768., 19776., 19024., 20048., 19280., 20320., 19536., 20592.,
      19792., 20864., 20048., 21136., 20304., 21408., 22096., 23312., 22352.,
      23584., 22608., 23856., 22864., 24128., 23120., 24400., 23376., 24672.,
      23632., 24944., 23888., 25216., 24144., 25488., 24400., 25760., 26192.,
      27664., 26448., 27936., 26704., 28208., 26960., 28480., 27216., 28752.,
      27472., 29024., 27728., 29296., 27984., 29568., 28240., 29840., 28496.,
      30112.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      324528., 326184., 327840., 329496., 330396., 332088., 333780., 335472.,
      381878., 383852., 385826., 387800., 388640., 390656., 392672., 394688.,
      440032., 442336., 444640., 446944., 447664., 450016., 452368., 454720.,
      387170., 389228., 391286., 393344., 393764., 395864., 397964., 400064.,
      333600., 335400., 337200., 339000., 339180., 341016., 342852., 344688.,
      420392., 422660., 424928., 427196., 426566., 428876., 431186., 433496.,
      492695., 495390., 498085., 500780., 499800., 502544., 505288., 508032.,
      565488., 568624., 571760., 574896., 573496., 576688., 579880., 583072.,
      495733., 498526., 501319., 504112., 502642., 505484., 508326., 511168.,
      425600., 428036., 430472., 432908., 431438., 433916., 436394., 438872.,
      520000., 522976., 525952., 528928., 526288., 529312., 532336., 535360.,
      607432., 610960., 614488., 618016., 614656., 618240., 621824., 625408.,
      694912., 699008., 703104., 707200., 703040., 707200., 711360., 715520.,
      607320., 610960., 614600., 618240., 614320., 618016., 621712., 625408.,
      519808., 522976., 526144., 529312., 525712., 528928., 532144., 535360.,
      425096., 428036., 430976., 433916., 429926., 432908., 435890., 438872.,
      495047., 498526., 502005., 505484., 500584., 504112., 507640., 511168.,
      564592., 568624., 572656., 576688., 570808., 574896., 578984., 583072.,
      491813., 495390., 498967., 502544., 497154., 500780., 504406., 508032.,
      419552., 422660., 425768., 428876., 424046., 427196., 430346., 433496.,
      332592., 335400., 338208., 341016., 336156., 339000., 341844., 344688.,
      385910., 389228., 392546., 395864., 389984., 393344., 396704., 400064.,
      438496., 442336., 446176., 450016., 443056., 446944., 450832., 454720.,
      380450., 383852., 387254., 390656., 384356., 387800., 391244., 394688.,
      323232., 326184., 329136., 332088., 326508., 329496., 332484., 335472.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19168., 19616., 20064., 20512., 19664., 20128., 20592., 21056., 20160.,
      20640., 21120., 21600., 20656., 21152., 21648., 22144., 21152., 21664.,
      22176., 22688., 21648., 22176., 22704., 23232., 22144., 22688., 23232.,
      23776., 22640., 23200., 23760., 24320., 23136., 23712., 24288., 24864.,
      23632., 24224., 24816., 25408., 27104., 27808., 28512., 29216., 27600.,
      28320., 29040., 29760., 28096., 28832., 29568., 30304., 28592., 29344.,
      30096., 30848., 29088., 29856., 30624., 31392., 29584., 30368., 31152.,
      31936., 30080., 30880., 31680., 32480., 30576., 31392., 32208., 33024.,
      31072., 31904., 32736., 33568., 31568., 32416., 33264., 34112., 35040.,
      36000., 36960., 37920., 35536., 36512., 37488., 38464., 36032., 37024.,
      38016., 39008., 36528., 37536., 38544., 39552., 37024., 38048., 39072.,
      40096., 37520., 38560., 39600., 40640., 38016., 39072., 40128., 41184.,
      38512., 39584., 40656., 41728., 39008., 40096., 41184., 42272., 39504.,
      40608., 41712., 42816., 42976., 44192., 45408., 46624., 43472., 44704.,
      45936., 47168., 43968., 45216., 46464., 47712., 44464., 45728., 46992.,
      48256., 44960., 46240., 47520., 48800., 45456., 46752., 48048., 49344.,
      45952., 47264., 48576., 49888., 46448., 47776., 49104., 50432., 46944.,
      48288., 49632., 50976., 47440., 48800., 50160., 51520., 50912., 52384.,
      53856., 55328., 51408., 52896., 54384., 55872., 51904., 53408., 54912.,
      56416., 52400., 53920., 55440., 56960., 52896., 54432., 55968., 57504.,
      53392., 54944., 56496., 58048., 53888., 55456., 57024., 58592., 54384.,
      55968., 57552., 59136., 54880., 56480., 58080., 59680., 55376., 56992.,
      58608., 60224.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      163254., 164748., 166242., 167736., 192178., 193900., 195622., 197344.,
      221528., 223472., 225416., 227360., 194992., 196672., 198352., 200032.,
      168078., 169500., 170922., 172344., 212023., 213598., 215173., 216748.,
      248577., 250390., 252203., 254016., 285404., 287448., 289492., 291536.,
      250292., 252056., 253820., 255584., 214963., 216454., 217945., 219436.,
      262856., 264464., 266072., 267680., 307160., 309008., 310856., 312704.,
      351520., 353600., 355680., 357760., 307328., 309120., 310912., 312704.,
      263144., 264656., 266168., 267680., 215719., 216958., 218197., 219436.,
      251321., 252742., 254163., 255584., 286748., 288344., 289940., 291536.,
      249900., 251272., 252644., 254016., 213283., 214438., 215593., 216748.,
      169590., 170508., 171426., 172344., 196882., 197932., 198982., 200032.,
      223832., 225008., 226184., 227360., 194320., 195328., 196336., 197344.,
      165198., 166044., 166890., 167736.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      10120., 10256., 10392., 10528., 10664., 10800., 10936., 11072., 11208.,
      11344., 11480., 11616., 11752., 11888., 12024., 12160., 12296., 12432.,
      12568., 12704., 14472., 14608., 14744., 14880., 15016., 15152., 15288.,
      15424., 15560., 15696., 15832., 15968., 16104., 16240., 16376., 16512.,
      16648., 16784., 16920., 17056., 18824., 18960., 19096., 19232., 19368.,
      19504., 19640., 19776., 19912., 20048., 20184., 20320., 20456., 20592.,
      20728., 20864., 21000., 21136., 21272., 21408., 23176., 23312., 23448.,
      23584., 23720., 23856., 23992., 24128., 24264., 24400., 24536., 24672.,
      24808., 24944., 25080., 25216., 25352., 25488., 25624., 25760., 27528.,
      27664., 27800., 27936., 28072., 28208., 28344., 28480., 28616., 28752.,
      28888., 29024., 29160., 29296., 29432., 29568., 29704., 29840., 29976.,
      30112.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      323232., 326508., 326184., 329496., 329136., 332484., 332088., 335472.,
      380450., 384356., 383852., 387800., 387254., 391244., 390656., 394688.,
      438496., 443056., 442336., 446944., 446176., 450832., 450016., 454720.,
      385910., 389984., 389228., 393344., 392546., 396704., 395864., 400064.,
      332592., 336156., 335400., 339000., 338208., 341844., 341016., 344688.,
      419552., 424046., 422660., 427196., 425768., 430346., 428876., 433496.,
      491813., 497154., 495390., 500780., 498967., 504406., 502544., 508032.,
      564592., 570808., 568624., 574896., 572656., 578984., 576688., 583072.,
      495047., 500584., 498526., 504112., 502005., 507640., 505484., 511168.,
      425096., 429926., 428036., 432908., 430976., 435890., 433916., 438872.,
      519808., 525712., 522976., 528928., 526144., 532144., 529312., 535360.,
      607320., 614320., 610960., 618016., 614600., 621712., 618240., 625408.,
      694912., 703040., 699008., 707200., 703104., 711360., 707200., 715520.,
      607432., 614656., 610960., 618240., 614488., 621824., 618016., 625408.,
      520000., 526288., 522976., 529312., 525952., 532336., 528928., 535360.,
      425600., 431438., 428036., 433916., 430472., 436394., 432908., 438872.,
      495733., 502642., 498526., 505484., 501319., 508326., 504112., 511168.,
      565488., 573496., 568624., 576688., 571760., 579880., 574896., 583072.,
      492695., 499800., 495390., 502544., 498085., 505288., 500780., 508032.,
      420392., 426566., 422660., 428876., 424928., 431186., 427196., 433496.,
      333600., 339180., 335400., 341016., 337200., 342852., 339000., 344688.,
      387170., 393764., 389228., 395864., 391286., 397964., 393344., 400064.,
      440032., 447664., 442336., 450016., 444640., 452368., 446944., 454720.,
      381878., 388640., 383852., 390656., 385826., 392672., 387800., 394688.,
      324528., 330396., 326184., 332088., 327840., 333780., 329496., 335472.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19360., 20240., 19616., 20512., 19872., 20784., 20128., 21056., 20384.,
      21328., 20640., 21600., 20896., 21872., 21152., 22144., 21408., 22416.,
      21664., 22688., 21920., 22960., 22176., 23232., 22432., 23504., 22688.,
      23776., 22944., 24048., 23200., 24320., 23456., 24592., 23712., 24864.,
      23968., 25136., 24224., 25408., 27552., 28944., 27808., 29216., 28064.,
      29488., 28320., 29760., 28576., 30032., 28832., 30304., 29088., 30576.,
      29344., 30848., 29600., 31120., 29856., 31392., 30112., 31664., 30368.,
      31936., 30624., 32208., 30880., 32480., 31136., 32752., 31392., 33024.,
      31648., 33296., 31904., 33568., 32160., 33840., 32416., 34112., 35744.,
      37648., 36000., 37920., 36256., 38192., 36512., 38464., 36768., 38736.,
      37024., 39008., 37280., 39280., 37536., 39552., 37792., 39824., 38048.,
      40096., 38304., 40368., 38560., 40640., 38816., 40912., 39072., 41184.,
      39328., 41456., 39584., 41728., 39840., 42000., 40096., 42272., 40352.,
      42544., 40608., 42816., 43936., 46352., 44192., 46624., 44448., 46896.,
      44704., 47168., 44960., 47440., 45216., 47712., 45472., 47984., 45728.,
      48256., 45984., 48528., 46240., 48800., 46496., 49072., 46752., 49344.,
      47008., 49616., 47264., 49888., 47520., 50160., 47776., 50432., 48032.,
      50704., 48288., 50976., 48544., 51248., 48800., 51520., 52128., 55056.,
      52384., 55328., 52640., 55600., 52896., 55872., 53152., 56144., 53408.,
      56416., 53664., 56688., 53920., 56960., 54176., 57232., 54432., 57504.,
      54688., 57776., 54944., 58048., 55200., 58320., 55456., 58592., 55712.,
      58864., 55968., 59136., 56224., 59408., 56480., 59680., 56736., 59952.,
      56992., 60224.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      643188.,  646464.,  649740.,  653016.,  649056.,  652368.,  655680.,
      658992.,  654924.,  658272.,  661620.,  664968.,  660792.,  664176.,
      667560.,  670944.,  756994.,  760900.,  764806.,  768712.,  763756.,
      767704.,  771652.,  775600.,  770518.,  774508.,  778498.,  782488.,
      777280.,  781312.,  785344.,  789376.,  872432.,  876992.,  881552.,
      886112.,  880064.,  884672.,  889280.,  893888.,  887696.,  892352.,
      897008.,  901664.,  895328.,  900032.,  904736.,  909440.,  767746.,
      771820.,  775894.,  779968.,  774340.,  778456.,  782572.,  786688.,
      780934.,  785092.,  789250.,  793408.,  787528.,  791728.,  795928.,
      800128.,  661620.,  665184.,  668748.,  672312.,  667200.,  670800.,
      674400.,  678000.,  672780.,  676416.,  680052.,  683688.,  678360.,
      682032.,  685704.,  689376.,  834610.,  839104.,  843598.,  848092.,
      840784.,  845320.,  849856.,  854392.,  846958.,  851536.,  856114.,
      860692.,  853132.,  857752.,  862372.,  866992.,  978285.,  983626.,
      988967.,  994308.,  985390.,  990780.,  996170.,  1001560., 992495.,
      997934.,  1003373., 1008812., 999600.,  1005088., 1010576., 1016064.,
      1122968., 1129184., 1135400., 1141616., 1130976., 1137248., 1143520.,
      1149792., 1138984., 1145312., 1151640., 1157968., 1146992., 1153376.,
      1159760., 1166144., 984557.,  990094.,  995631.,  1001168., 991466.,
      997052.,  1002638., 1008224., 998375.,  1004010., 1009645., 1015280.,
      1005284., 1010968., 1016652., 1022336., 845362.,  850192.,  855022.,
      859852.,  851200.,  856072.,  860944.,  865816.,  857038.,  861952.,
      866866.,  871780.,  862876.,  867832.,  872788.,  877744.,  1033712.,
      1039616., 1045520., 1051424., 1040000., 1045952., 1051904., 1057856.,
      1046288., 1052288., 1058288., 1064288., 1052576., 1058624., 1064672.,
      1070720., 1207640., 1214640., 1221640., 1228640., 1214864., 1221920.,
      1228976., 1236032., 1222088., 1229200., 1236312., 1243424., 1229312.,
      1236480., 1243648., 1250816., 1381696., 1389824., 1397952., 1406080.,
      1389824., 1398016., 1406208., 1414400., 1397952., 1406208., 1414464.,
      1422720., 1406080., 1414400., 1422720., 1431040., 1207640., 1214864.,
      1222088., 1229312., 1214640., 1221920., 1229200., 1236480., 1221640.,
      1228976., 1236312., 1243648., 1228640., 1236032., 1243424., 1250816.,
      1033712., 1040000., 1046288., 1052576., 1039616., 1045952., 1052288.,
      1058624., 1045520., 1051904., 1058288., 1064672., 1051424., 1057856.,
      1064288., 1070720., 845362.,  851200.,  857038.,  862876.,  850192.,
      856072.,  861952.,  867832.,  855022.,  860944.,  866866.,  872788.,
      859852.,  865816.,  871780.,  877744.,  984557.,  991466.,  998375.,
      1005284., 990094.,  997052.,  1004010., 1010968., 995631.,  1002638.,
      1009645., 1016652., 1001168., 1008224., 1015280., 1022336., 1122968.,
      1130976., 1138984., 1146992., 1129184., 1137248., 1145312., 1153376.,
      1135400., 1143520., 1151640., 1159760., 1141616., 1149792., 1157968.,
      1166144., 978285.,  985390.,  992495.,  999600.,  983626.,  990780.,
      997934.,  1005088., 988967.,  996170.,  1003373., 1010576., 994308.,
      1001560., 1008812., 1016064., 834610.,  840784.,  846958.,  853132.,
      839104.,  845320.,  851536.,  857752.,  843598.,  849856.,  856114.,
      862372.,  848092.,  854392.,  860692.,  866992.,  661620.,  667200.,
      672780.,  678360.,  665184.,  670800.,  676416.,  682032.,  668748.,
      674400.,  680052.,  685704.,  672312.,  678000.,  683688.,  689376.,
      767746.,  774340.,  780934.,  787528.,  771820.,  778456.,  785092.,
      791728.,  775894.,  782572.,  789250.,  795928.,  779968.,  786688.,
      793408.,  800128.,  872432.,  880064.,  887696.,  895328.,  876992.,
      884672.,  892352.,  900032.,  881552.,  889280.,  897008.,  904736.,
      886112.,  893888.,  901664.,  909440.,  756994.,  763756.,  770518.,
      777280.,  760900.,  767704.,  774508.,  781312.,  764806.,  771652.,
      778498.,  785344.,  768712.,  775600.,  782488.,  789376.,  643188.,
      649056.,  654924.,  660792.,  646464.,  652368.,  658272.,  664176.,
      649740.,  655680.,  661620.,  667560.,  653016.,  658992.,  664968.,
      670944.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID1x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      37840.,  38720.,  39600.,  40480.,  38336.,  39232.,  40128.,  41024.,
      38832.,  39744.,  40656.,  41568.,  39328.,  40256.,  41184.,  42112.,
      39824.,  40768.,  41712.,  42656.,  40320.,  41280.,  42240.,  43200.,
      40816.,  41792.,  42768.,  43744.,  41312.,  42304.,  43296.,  44288.,
      41808.,  42816.,  43824.,  44832.,  42304.,  43328.,  44352.,  45376.,
      42800.,  43840.,  44880.,  45920.,  43296.,  44352.,  45408.,  46464.,
      43792.,  44864.,  45936.,  47008.,  44288.,  45376.,  46464.,  47552.,
      44784.,  45888.,  46992.,  48096.,  45280.,  46400.,  47520.,  48640.,
      45776.,  46912.,  48048.,  49184.,  46272.,  47424.,  48576.,  49728.,
      46768.,  47936.,  49104.,  50272.,  47264.,  48448.,  49632.,  50816.,
      53712.,  55104.,  56496.,  57888.,  54208.,  55616.,  57024.,  58432.,
      54704.,  56128.,  57552.,  58976.,  55200.,  56640.,  58080.,  59520.,
      55696.,  57152.,  58608.,  60064.,  56192.,  57664.,  59136.,  60608.,
      56688.,  58176.,  59664.,  61152.,  57184.,  58688.,  60192.,  61696.,
      57680.,  59200.,  60720.,  62240.,  58176.,  59712.,  61248.,  62784.,
      58672.,  60224.,  61776.,  63328.,  59168.,  60736.,  62304.,  63872.,
      59664.,  61248.,  62832.,  64416.,  60160.,  61760.,  63360.,  64960.,
      60656.,  62272.,  63888.,  65504.,  61152.,  62784.,  64416.,  66048.,
      61648.,  63296.,  64944.,  66592.,  62144.,  63808.,  65472.,  67136.,
      62640.,  64320.,  66000.,  67680.,  63136.,  64832.,  66528.,  68224.,
      69584.,  71488.,  73392.,  75296.,  70080.,  72000.,  73920.,  75840.,
      70576.,  72512.,  74448.,  76384.,  71072.,  73024.,  74976.,  76928.,
      71568.,  73536.,  75504.,  77472.,  72064.,  74048.,  76032.,  78016.,
      72560.,  74560.,  76560.,  78560.,  73056.,  75072.,  77088.,  79104.,
      73552.,  75584.,  77616.,  79648.,  74048.,  76096.,  78144.,  80192.,
      74544.,  76608.,  78672.,  80736.,  75040.,  77120.,  79200.,  81280.,
      75536.,  77632.,  79728.,  81824.,  76032.,  78144.,  80256.,  82368.,
      76528.,  78656.,  80784.,  82912.,  77024.,  79168.,  81312.,  83456.,
      77520.,  79680.,  81840.,  84000.,  78016.,  80192.,  82368.,  84544.,
      78512.,  80704.,  82896.,  85088.,  79008.,  81216.,  83424.,  85632.,
      85456.,  87872.,  90288.,  92704.,  85952.,  88384.,  90816.,  93248.,
      86448.,  88896.,  91344.,  93792.,  86944.,  89408.,  91872.,  94336.,
      87440.,  89920.,  92400.,  94880.,  87936.,  90432.,  92928.,  95424.,
      88432.,  90944.,  93456.,  95968.,  88928.,  91456.,  93984.,  96512.,
      89424.,  91968.,  94512.,  97056.,  89920.,  92480.,  95040.,  97600.,
      90416.,  92992.,  95568.,  98144.,  90912.,  93504.,  96096.,  98688.,
      91408.,  94016.,  96624.,  99232.,  91904.,  94528.,  97152.,  99776.,
      92400.,  95040.,  97680.,  100320., 92896.,  95552.,  98208.,  100864.,
      93392.,  96064.,  98736.,  101408., 93888.,  96576.,  99264.,  101952.,
      94384.,  97088.,  99792.,  102496., 94880.,  97600.,  100320., 103040.,
      101328., 104256., 107184., 110112., 101824., 104768., 107712., 110656.,
      102320., 105280., 108240., 111200., 102816., 105792., 108768., 111744.,
      103312., 106304., 109296., 112288., 103808., 106816., 109824., 112832.,
      104304., 107328., 110352., 113376., 104800., 107840., 110880., 113920.,
      105296., 108352., 111408., 114464., 105792., 108864., 111936., 115008.,
      106288., 109376., 112464., 115552., 106784., 109888., 112992., 116096.,
      107280., 110400., 113520., 116640., 107776., 110912., 114048., 117184.,
      108272., 111424., 114576., 117728., 108768., 111936., 115104., 118272.,
      109264., 112448., 115632., 118816., 109760., 112960., 116160., 119360.,
      110256., 113472., 116688., 119904., 110752., 113984., 117216., 120448.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      183912., 230340., 276924., 231060., 185064., 233490., 292200.,
      351015., 292650., 234210., 283644., 354690., 425754., 354690.,
      283644., 234210., 292650., 351015., 292200., 233490., 185064.,
      231060., 276924., 230340., 183912.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4350., 4428., 4506., 4584., 4662., 4818., 4896., 4974., 5052.,
      5130., 5286., 5364., 5442., 5520., 5598., 5754., 5832., 5910.,
      5988., 6066., 6222., 6300., 6378., 6456., 6534.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      365544., 367824., 457800., 460680., 550356., 553848., 459180., 462120.,
      367752., 370128., 463950., 466980., 580575., 584400., 697395., 702030.,
      581400., 585300., 465270., 468420., 563436., 567288., 704520., 709380.,
      845622., 851508., 704430., 709380., 563292., 567288., 465030., 468420.,
      581025., 585300., 696855., 702030., 580050., 584400., 463470., 466980.,
      367272., 370128., 458520., 462120., 549492., 553848., 457020., 460680.,
      364872., 367824.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8214.,  8700.,  8358.,  8856.,  8502.,  9012.,  8646.,  9168.,  8790.,
      9324.,  9078.,  9636.,  9222.,  9792.,  9366.,  9948.,  9510.,  10104.,
      9654.,  10260., 9942.,  10572., 10086., 10728., 10230., 10884., 10374.,
      11040., 10518., 11196., 10806., 11508., 10950., 11664., 11094., 11820.,
      11238., 11976., 11382., 12132., 11670., 12444., 11814., 12600., 11958.,
      12756., 12102., 12912., 12246., 13068.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      728808.,  731088.,  733368.,  735648.,  912720.,  915600.,  918480.,
      921360.,  1097220., 1100712., 1104204., 1107696., 915420.,  918360.,
      921300.,  924240.,  733128.,  735504.,  737880.,  740256.,  924870.,
      927900.,  930930.,  933960.,  1157325., 1161150., 1164975., 1168800.,
      1390155., 1394790., 1399425., 1404060., 1158900., 1162800., 1166700.,
      1170600., 927390.,  930540.,  933690.,  936840.,  1123020., 1126872.,
      1130724., 1134576., 1404180., 1409040., 1413900., 1418760., 1685358.,
      1691244., 1697130., 1703016., 1403910., 1408860., 1413810., 1418760.,
      1122588., 1126584., 1130580., 1134576., 926670.,  930060.,  933450.,
      936840.,  1157775., 1162050., 1166325., 1170600., 1388535., 1393710.,
      1398885., 1404060., 1155750., 1160100., 1164450., 1168800., 923430.,
      926940.,  930450.,  933960.,  731688.,  734544.,  737400.,  740256.,
      913440.,  917040.,  920640.,  924240.,  1094628., 1098984., 1103340.,
      1107696., 910380.,  914040.,  917700.,  921360.,  726792.,  729744.,
      732696.,  735648.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15942., 16428., 16914., 17400., 16218., 16716., 17214., 17712., 16494.,
      17004., 17514., 18024., 16770., 17292., 17814., 18336., 17046., 17580.,
      18114., 18648., 17598., 18156., 18714., 19272., 17874., 18444., 19014.,
      19584., 18150., 18732., 19314., 19896., 18426., 19020., 19614., 20208.,
      18702., 19308., 19914., 20520., 19254., 19884., 20514., 21144., 19530.,
      20172., 20814., 21456., 19806., 20460., 21114., 21768., 20082., 20748.,
      21414., 22080., 20358., 21036., 21714., 22392., 20910., 21612., 22314.,
      23016., 21186., 21900., 22614., 23328., 21462., 22188., 22914., 23640.,
      21738., 22476., 23214., 23952., 22014., 22764., 23514., 24264., 22566.,
      23340., 24114., 24888., 22842., 23628., 24414., 25200., 23118., 23916.,
      24714., 25512., 23394., 24204., 25014., 25824., 23670., 24492., 25314.,
      26136.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      364872., 367824., 457020., 460680., 549492., 553848., 458520., 462120.,
      367272., 370128., 463470., 466980., 580050., 584400., 696855., 702030.,
      581025., 585300., 465030., 468420., 563292., 567288., 704430., 709380.,
      845622., 851508., 704520., 709380., 563436., 567288., 465270., 468420.,
      581400., 585300., 697395., 702030., 580575., 584400., 463950., 466980.,
      367752., 370128., 459180., 462120., 550356., 553848., 457800., 460680.,
      365544., 367824.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8622.,  8700.,  8778.,  8856.,  8934.,  9012.,  9090.,  9168.,  9246.,
      9324.,  9558.,  9636.,  9714.,  9792.,  9870.,  9948.,  10026., 10104.,
      10182., 10260., 10494., 10572., 10650., 10728., 10806., 10884., 10962.,
      11040., 11118., 11196., 11430., 11508., 11586., 11664., 11742., 11820.,
      11898., 11976., 12054., 12132., 12366., 12444., 12522., 12600., 12678.,
      12756., 12834., 12912., 12990., 13068.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      725232.,  729744.,  731088.,  735648.,  908340.,  914040.,  915600.,
      921360.,  1092072., 1098984., 1100712., 1107696., 911220.,  917040.,
      918360.,  924240.,  729840.,  734544.,  735504.,  740256.,  920940.,
      926940.,  927900.,  933960.,  1152525., 1160100., 1161150., 1168800.,
      1384530., 1393710., 1394790., 1404060., 1154325., 1162050., 1162800.,
      1170600., 923820.,  930060.,  930540.,  936840.,  1118952., 1126584.,
      1126872., 1134576., 1399230., 1408860., 1409040., 1418760., 1679580.,
      1691244., 1691244., 1703016., 1399230., 1409040., 1408860., 1418760.,
      1118952., 1126872., 1126584., 1134576., 923820.,  930540.,  930060.,
      936840.,  1154325., 1162800., 1162050., 1170600., 1384530., 1394790.,
      1393710., 1404060., 1152525., 1161150., 1160100., 1168800., 920940.,
      927900.,  926940.,  933960.,  729840.,  735504.,  734544.,  740256.,
      911220.,  918360.,  917040.,  924240.,  1092072., 1100712., 1098984.,
      1107696., 908340.,  915600.,  914040.,  921360.,  725232.,  731088.,
      729744.,  735648.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16284., 17244., 16428., 17400., 16572., 17556., 16716., 17712., 16860.,
      17868., 17004., 18024., 17148., 18180., 17292., 18336., 17436., 18492.,
      17580., 18648., 18012., 19116., 18156., 19272., 18300., 19428., 18444.,
      19584., 18588., 19740., 18732., 19896., 18876., 20052., 19020., 20208.,
      19164., 20364., 19308., 20520., 19740., 20988., 19884., 21144., 20028.,
      21300., 20172., 21456., 20316., 21612., 20460., 21768., 20604., 21924.,
      20748., 22080., 20892., 22236., 21036., 22392., 21468., 22860., 21612.,
      23016., 21756., 23172., 21900., 23328., 22044., 23484., 22188., 23640.,
      22332., 23796., 22476., 23952., 22620., 24108., 22764., 24264., 23196.,
      24732., 23340., 24888., 23484., 25044., 23628., 25200., 23772., 25356.,
      23916., 25512., 24060., 25668., 24204., 25824., 24348., 25980., 24492.,
      26136.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1445952., 1450464., 1454976., 1459488., 1457616., 1462176., 1466736.,
      1471296., 1810980., 1816680., 1822380., 1828080., 1825440., 1831200.,
      1836960., 1842720., 2177232., 2184144., 2191056., 2197968., 2194440.,
      2201424., 2208408., 2215392., 1816620., 1822440., 1828260., 1834080.,
      1830840., 1836720., 1842600., 1848480., 1454976., 1459680., 1464384.,
      1469088., 1466256., 1471008., 1475760., 1480512., 1835880., 1841880.,
      1847880., 1853880., 1849740., 1855800., 1861860., 1867920., 2297475.,
      2305050., 2312625., 2320200., 2314650., 2322300., 2329950., 2337600.,
      2759880., 2769060., 2778240., 2787420., 2780310., 2789580., 2798850.,
      2808120., 2300925., 2308650., 2316375., 2324100., 2317800., 2325600.,
      2333400., 2341200., 1841400., 1847640., 1853880., 1860120., 1854780.,
      1861080., 1867380., 1873680., 2230272., 2237904., 2245536., 2253168.,
      2246040., 2253744., 2261448., 2269152., 2788830., 2798460., 2808090.,
      2817720., 2808360., 2818080., 2827800., 2837520., 3347496., 3359160.,
      3370824., 3382488., 3370716., 3382488., 3394260., 3406032., 2788650.,
      2798460., 2808270., 2818080., 2807820., 2817720., 2827620., 2837520.,
      2229984., 2237904., 2245824., 2253744., 2245176., 2253168., 2261160.,
      2269152., 1840920., 1847640., 1854360., 1861080., 1853340., 1860120.,
      1866900., 1873680., 2300175., 2308650., 2317125., 2325600., 2315550.,
      2324100., 2332650., 2341200., 2758800., 2769060., 2779320., 2789580.,
      2777070., 2787420., 2797770., 2808120., 2296425., 2305050., 2313675.,
      2322300., 2311500., 2320200., 2328900., 2337600., 1834920., 1841880.,
      1848840., 1855800., 1846860., 1853880., 1860900., 1867920., 1454016.,
      1459680., 1465344., 1471008., 1463376., 1469088., 1474800., 1480512.,
      1815300., 1822440., 1829580., 1836720., 1826880., 1834080., 1841280.,
      1848480., 2175504., 2184144., 2192784., 2201424., 2189256., 2197968.,
      2206680., 2215392., 1809420., 1816680., 1823940., 1831200., 1820760.,
      1828080., 1835400., 1842720., 1444608., 1450464., 1456320., 1462176.,
      1453584., 1459488., 1465392., 1471296.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31608., 32568., 33528., 34488., 31884., 32856., 33828., 34800., 32160.,
      33144., 34128., 35112., 32436., 33432., 34428., 35424., 32712., 33720.,
      34728., 35736., 32988., 34008., 35028., 36048., 33264., 34296., 35328.,
      36360., 33540., 34584., 35628., 36672., 33816., 34872., 35928., 36984.,
      34092., 35160., 36228., 37296., 34920., 36024., 37128., 38232., 35196.,
      36312., 37428., 38544., 35472., 36600., 37728., 38856., 35748., 36888.,
      38028., 39168., 36024., 37176., 38328., 39480., 36300., 37464., 38628.,
      39792., 36576., 37752., 38928., 40104., 36852., 38040., 39228., 40416.,
      37128., 38328., 39528., 40728., 37404., 38616., 39828., 41040., 38232.,
      39480., 40728., 41976., 38508., 39768., 41028., 42288., 38784., 40056.,
      41328., 42600., 39060., 40344., 41628., 42912., 39336., 40632., 41928.,
      43224., 39612., 40920., 42228., 43536., 39888., 41208., 42528., 43848.,
      40164., 41496., 42828., 44160., 40440., 41784., 43128., 44472., 40716.,
      42072., 43428., 44784., 41544., 42936., 44328., 45720., 41820., 43224.,
      44628., 46032., 42096., 43512., 44928., 46344., 42372., 43800., 45228.,
      46656., 42648., 44088., 45528., 46968., 42924., 44376., 45828., 47280.,
      43200., 44664., 46128., 47592., 43476., 44952., 46428., 47904., 43752.,
      45240., 46728., 48216., 44028., 45528., 47028., 48528., 44856., 46392.,
      47928., 49464., 45132., 46680., 48228., 49776., 45408., 46968., 48528.,
      50088., 45684., 47256., 48828., 50400., 45960., 47544., 49128., 50712.,
      46236., 47832., 49428., 51024., 46512., 48120., 49728., 51336., 46788.,
      48408., 50028., 51648., 47064., 48696., 50328., 51960., 47340., 48984.,
      50628., 52272.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      726792.,  729744.,  732696.,  735648.,  910380.,  914040.,  917700.,
      921360.,  1094628., 1098984., 1103340., 1107696., 913440.,  917040.,
      920640.,  924240.,  731688.,  734544.,  737400.,  740256.,  923430.,
      926940.,  930450.,  933960.,  1155750., 1160100., 1164450., 1168800.,
      1388535., 1393710., 1398885., 1404060., 1157775., 1162050., 1166325.,
      1170600., 926670.,  930060.,  933450.,  936840.,  1122588., 1126584.,
      1130580., 1134576., 1403910., 1408860., 1413810., 1418760., 1685358.,
      1691244., 1697130., 1703016., 1404180., 1409040., 1413900., 1418760.,
      1123020., 1126872., 1130724., 1134576., 927390.,  930540.,  933690.,
      936840.,  1158900., 1162800., 1166700., 1170600., 1390155., 1394790.,
      1399425., 1404060., 1157325., 1161150., 1164975., 1168800., 924870.,
      927900.,  930930.,  933960.,  733128.,  735504.,  737880.,  740256.,
      915420.,  918360.,  921300.,  924240.,  1097220., 1100712., 1104204.,
      1107696., 912720.,  915600.,  918480.,  921360.,  728808.,  731088.,
      733368.,  735648.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17166., 17244., 17322., 17400., 17478., 17556., 17634., 17712., 17790.,
      17868., 17946., 18024., 18102., 18180., 18258., 18336., 18414., 18492.,
      18570., 18648., 19038., 19116., 19194., 19272., 19350., 19428., 19506.,
      19584., 19662., 19740., 19818., 19896., 19974., 20052., 20130., 20208.,
      20286., 20364., 20442., 20520., 20910., 20988., 21066., 21144., 21222.,
      21300., 21378., 21456., 21534., 21612., 21690., 21768., 21846., 21924.,
      22002., 22080., 22158., 22236., 22314., 22392., 22782., 22860., 22938.,
      23016., 23094., 23172., 23250., 23328., 23406., 23484., 23562., 23640.,
      23718., 23796., 23874., 23952., 24030., 24108., 24186., 24264., 24654.,
      24732., 24810., 24888., 24966., 25044., 25122., 25200., 25278., 25356.,
      25434., 25512., 25590., 25668., 25746., 25824., 25902., 25980., 26058.,
      26136.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1444608., 1453584., 1450464., 1459488., 1456320., 1465392., 1462176.,
      1471296., 1809420., 1820760., 1816680., 1828080., 1823940., 1835400.,
      1831200., 1842720., 2175504., 2189256., 2184144., 2197968., 2192784.,
      2206680., 2201424., 2215392., 1815300., 1826880., 1822440., 1834080.,
      1829580., 1841280., 1836720., 1848480., 1454016., 1463376., 1459680.,
      1469088., 1465344., 1474800., 1471008., 1480512., 1834920., 1846860.,
      1841880., 1853880., 1848840., 1860900., 1855800., 1867920., 2296425.,
      2311500., 2305050., 2320200., 2313675., 2328900., 2322300., 2337600.,
      2758800., 2777070., 2769060., 2787420., 2779320., 2797770., 2789580.,
      2808120., 2300175., 2315550., 2308650., 2324100., 2317125., 2332650.,
      2325600., 2341200., 1840920., 1853340., 1847640., 1860120., 1854360.,
      1866900., 1861080., 1873680., 2229984., 2245176., 2237904., 2253168.,
      2245824., 2261160., 2253744., 2269152., 2788650., 2807820., 2798460.,
      2817720., 2808270., 2827620., 2818080., 2837520., 3347496., 3370716.,
      3359160., 3382488., 3370824., 3394260., 3382488., 3406032., 2788830.,
      2808360., 2798460., 2818080., 2808090., 2827800., 2817720., 2837520.,
      2230272., 2246040., 2237904., 2253744., 2245536., 2261448., 2253168.,
      2269152., 1841400., 1854780., 1847640., 1861080., 1853880., 1867380.,
      1860120., 1873680., 2300925., 2317800., 2308650., 2325600., 2316375.,
      2333400., 2324100., 2341200., 2759880., 2780310., 2769060., 2789580.,
      2778240., 2798850., 2787420., 2808120., 2297475., 2314650., 2305050.,
      2322300., 2312625., 2329950., 2320200., 2337600., 1835880., 1849740.,
      1841880., 1855800., 1847880., 1861860., 1853880., 1867920., 1454976.,
      1466256., 1459680., 1471008., 1464384., 1475760., 1469088., 1480512.,
      1816620., 1830840., 1822440., 1836720., 1828260., 1842600., 1834080.,
      1848480., 2177232., 2194440., 2184144., 2201424., 2191056., 2208408.,
      2197968., 2215392., 1810980., 1825440., 1816680., 1831200., 1822380.,
      1836960., 1828080., 1842720., 1445952., 1457616., 1450464., 1462176.,
      1454976., 1466736., 1459488., 1471296.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      32424., 34332., 32568., 34488., 32712., 34644., 32856., 34800., 33000.,
      34956., 33144., 35112., 33288., 35268., 33432., 35424., 33576., 35580.,
      33720., 35736., 33864., 35892., 34008., 36048., 34152., 36204., 34296.,
      36360., 34440., 36516., 34584., 36672., 34728., 36828., 34872., 36984.,
      35016., 37140., 35160., 37296., 35880., 38076., 36024., 38232., 36168.,
      38388., 36312., 38544., 36456., 38700., 36600., 38856., 36744., 39012.,
      36888., 39168., 37032., 39324., 37176., 39480., 37320., 39636., 37464.,
      39792., 37608., 39948., 37752., 40104., 37896., 40260., 38040., 40416.,
      38184., 40572., 38328., 40728., 38472., 40884., 38616., 41040., 39336.,
      41820., 39480., 41976., 39624., 42132., 39768., 42288., 39912., 42444.,
      40056., 42600., 40200., 42756., 40344., 42912., 40488., 43068., 40632.,
      43224., 40776., 43380., 40920., 43536., 41064., 43692., 41208., 43848.,
      41352., 44004., 41496., 44160., 41640., 44316., 41784., 44472., 41928.,
      44628., 42072., 44784., 42792., 45564., 42936., 45720., 43080., 45876.,
      43224., 46032., 43368., 46188., 43512., 46344., 43656., 46500., 43800.,
      46656., 43944., 46812., 44088., 46968., 44232., 47124., 44376., 47280.,
      44520., 47436., 44664., 47592., 44808., 47748., 44952., 47904., 45096.,
      48060., 45240., 48216., 45384., 48372., 45528., 48528., 46248., 49308.,
      46392., 49464., 46536., 49620., 46680., 49776., 46824., 49932., 46968.,
      50088., 47112., 50244., 47256., 50400., 47400., 50556., 47544., 50712.,
      47688., 50868., 47832., 51024., 47976., 51180., 48120., 51336., 48264.,
      51492., 48408., 51648., 48552., 51804., 48696., 51960., 48840., 52116.,
      48984., 52272.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2880240., 2889216., 2898192., 2907168., 2891904., 2900928., 2909952.,
      2918976., 2903568., 2912640., 2921712., 2930784., 2915232., 2924352.,
      2933472., 2942592., 3607500., 3618840., 3630180., 3641520., 3621960.,
      3633360., 3644760., 3656160., 3636420., 3647880., 3659340., 3670800.,
      3650880., 3662400., 3673920., 3685440., 4337256., 4351008., 4364760.,
      4378512., 4354464., 4368288., 4382112., 4395936., 4371672., 4385568.,
      4399464., 4413360., 4388880., 4402848., 4416816., 4430784., 3619020.,
      3630600., 3642180., 3653760., 3633240., 3644880., 3656520., 3668160.,
      3647460., 3659160., 3670860., 3682560., 3661680., 3673440., 3685200.,
      3696960., 2898672., 2908032., 2917392., 2926752., 2909952., 2919360.,
      2928768., 2938176., 2921232., 2930688., 2940144., 2949600., 2932512.,
      2942016., 2951520., 2961024., 3657900., 3669840., 3681780., 3693720.,
      3671760., 3683760., 3695760., 3707760., 3685620., 3697680., 3709740.,
      3721800., 3699480., 3711600., 3723720., 3735840., 4577775., 4592850.,
      4607925., 4623000., 4594950., 4610100., 4625250., 4640400., 4612125.,
      4627350., 4642575., 4657800., 4629300., 4644600., 4659900., 4675200.,
      5499330., 5517600., 5535870., 5554140., 5519760., 5538120., 5556480.,
      5574840., 5540190., 5558640., 5577090., 5595540., 5560620., 5579160.,
      5597700., 5616240., 4584975., 4600350., 4615725., 4631100., 4601850.,
      4617300., 4632750., 4648200., 4618725., 4634250., 4649775., 4665300.,
      4635600., 4651200., 4666800., 4682400., 3669420., 3681840., 3694260.,
      3706680., 3682800., 3695280., 3707760., 3720240., 3696180., 3708720.,
      3721260., 3733800., 3709560., 3722160., 3734760., 3747360., 4444776.,
      4459968., 4475160., 4490352., 4460544., 4475808., 4491072., 4506336.,
      4476312., 4491648., 4506984., 4522320., 4492080., 4507488., 4522896.,
      4538304., 5558130., 5577300., 5596470., 5615640., 5577660., 5596920.,
      5616180., 5635440., 5597190., 5616540., 5635890., 5655240., 5616720.,
      5636160., 5655600., 5675040., 6671772., 6694992., 6718212., 6741432.,
      6694992., 6718320., 6741648., 6764976., 6718212., 6741648., 6765084.,
      6788520., 6741432., 6764976., 6788520., 6812064., 5558130., 5577660.,
      5597190., 5616720., 5577300., 5596920., 5616540., 5636160., 5596470.,
      5616180., 5635890., 5655600., 5615640., 5635440., 5655240., 5675040.,
      4444776., 4460544., 4476312., 4492080., 4459968., 4475808., 4491648.,
      4507488., 4475160., 4491072., 4506984., 4522896., 4490352., 4506336.,
      4522320., 4538304., 3669420., 3682800., 3696180., 3709560., 3681840.,
      3695280., 3708720., 3722160., 3694260., 3707760., 3721260., 3734760.,
      3706680., 3720240., 3733800., 3747360., 4584975., 4601850., 4618725.,
      4635600., 4600350., 4617300., 4634250., 4651200., 4615725., 4632750.,
      4649775., 4666800., 4631100., 4648200., 4665300., 4682400., 5499330.,
      5519760., 5540190., 5560620., 5517600., 5538120., 5558640., 5579160.,
      5535870., 5556480., 5577090., 5597700., 5554140., 5574840., 5595540.,
      5616240., 4577775., 4594950., 4612125., 4629300., 4592850., 4610100.,
      4627350., 4644600., 4607925., 4625250., 4642575., 4659900., 4623000.,
      4640400., 4657800., 4675200., 3657900., 3671760., 3685620., 3699480.,
      3669840., 3683760., 3697680., 3711600., 3681780., 3695760., 3709740.,
      3723720., 3693720., 3707760., 3721800., 3735840., 2898672., 2909952.,
      2921232., 2932512., 2908032., 2919360., 2930688., 2942016., 2917392.,
      2928768., 2940144., 2951520., 2926752., 2938176., 2949600., 2961024.,
      3619020., 3633240., 3647460., 3661680., 3630600., 3644880., 3659160.,
      3673440., 3642180., 3656520., 3670860., 3685200., 3653760., 3668160.,
      3682560., 3696960., 4337256., 4354464., 4371672., 4388880., 4351008.,
      4368288., 4385568., 4402848., 4364760., 4382112., 4399464., 4416816.,
      4378512., 4395936., 4413360., 4430784., 3607500., 3621960., 3636420.,
      3650880., 3618840., 3633360., 3647880., 3662400., 3630180., 3644760.,
      3659340., 3673920., 3641520., 3656160., 3670800., 3685440., 2880240.,
      2891904., 2903568., 2915232., 2889216., 2900928., 2912640., 2924352.,
      2898192., 2909952., 2921712., 2933472., 2907168., 2918976., 2930784.,
      2942592.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62940., 64848., 66756.,  68664.,  63216., 65136., 67056.,  68976.,
      63492., 65424., 67356.,  69288.,  63768., 65712., 67656.,  69600.,
      64044., 66000., 67956.,  69912.,  64320., 66288., 68256.,  70224.,
      64596., 66576., 68556.,  70536.,  64872., 66864., 68856.,  70848.,
      65148., 67152., 69156.,  71160.,  65424., 67440., 69456.,  71472.,
      65700., 67728., 69756.,  71784.,  65976., 68016., 70056.,  72096.,
      66252., 68304., 70356.,  72408.,  66528., 68592., 70656.,  72720.,
      66804., 68880., 70956.,  73032.,  67080., 69168., 71256.,  73344.,
      67356., 69456., 71556.,  73656.,  67632., 69744., 71856.,  73968.,
      67908., 70032., 72156.,  74280.,  68184., 70320., 72456.,  74592.,
      69564., 71760., 73956.,  76152.,  69840., 72048., 74256.,  76464.,
      70116., 72336., 74556.,  76776.,  70392., 72624., 74856.,  77088.,
      70668., 72912., 75156.,  77400.,  70944., 73200., 75456.,  77712.,
      71220., 73488., 75756.,  78024.,  71496., 73776., 76056.,  78336.,
      71772., 74064., 76356.,  78648.,  72048., 74352., 76656.,  78960.,
      72324., 74640., 76956.,  79272.,  72600., 74928., 77256.,  79584.,
      72876., 75216., 77556.,  79896.,  73152., 75504., 77856.,  80208.,
      73428., 75792., 78156.,  80520.,  73704., 76080., 78456.,  80832.,
      73980., 76368., 78756.,  81144.,  74256., 76656., 79056.,  81456.,
      74532., 76944., 79356.,  81768.,  74808., 77232., 79656.,  82080.,
      76188., 78672., 81156.,  83640.,  76464., 78960., 81456.,  83952.,
      76740., 79248., 81756.,  84264.,  77016., 79536., 82056.,  84576.,
      77292., 79824., 82356.,  84888.,  77568., 80112., 82656.,  85200.,
      77844., 80400., 82956.,  85512.,  78120., 80688., 83256.,  85824.,
      78396., 80976., 83556.,  86136.,  78672., 81264., 83856.,  86448.,
      78948., 81552., 84156.,  86760.,  79224., 81840., 84456.,  87072.,
      79500., 82128., 84756.,  87384.,  79776., 82416., 85056.,  87696.,
      80052., 82704., 85356.,  88008.,  80328., 82992., 85656.,  88320.,
      80604., 83280., 85956.,  88632.,  80880., 83568., 86256.,  88944.,
      81156., 83856., 86556.,  89256.,  81432., 84144., 86856.,  89568.,
      82812., 85584., 88356.,  91128.,  83088., 85872., 88656.,  91440.,
      83364., 86160., 88956.,  91752.,  83640., 86448., 89256.,  92064.,
      83916., 86736., 89556.,  92376.,  84192., 87024., 89856.,  92688.,
      84468., 87312., 90156.,  93000.,  84744., 87600., 90456.,  93312.,
      85020., 87888., 90756.,  93624.,  85296., 88176., 91056.,  93936.,
      85572., 88464., 91356.,  94248.,  85848., 88752., 91656.,  94560.,
      86124., 89040., 91956.,  94872.,  86400., 89328., 92256.,  95184.,
      86676., 89616., 92556.,  95496.,  86952., 89904., 92856.,  95808.,
      87228., 90192., 93156.,  96120.,  87504., 90480., 93456.,  96432.,
      87780., 90768., 93756.,  96744.,  88056., 91056., 94056.,  97056.,
      89436., 92496., 95556.,  98616.,  89712., 92784., 95856.,  98928.,
      89988., 93072., 96156.,  99240.,  90264., 93360., 96456.,  99552.,
      90540., 93648., 96756.,  99864.,  90816., 93936., 97056.,  100176.,
      91092., 94224., 97356.,  100488., 91368., 94512., 97656.,  100800.,
      91644., 94800., 97956.,  101112., 91920., 95088., 98256.,  101424.,
      92196., 95376., 98556.,  101736., 92472., 95664., 98856.,  102048.,
      92748., 95952., 99156.,  102360., 93024., 96240., 99456.,  102672.,
      93300., 96528., 99756.,  102984., 93576., 96816., 100056., 103296.,
      93852., 97104., 100356., 103608., 94128., 97392., 100656., 103920.,
      94404., 97680., 100956., 104232., 94680., 97968., 101256., 104544.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      312450., 375564., 438858., 376572., 314130., 396600., 476385.,
      556290., 477015., 397650., 481695., 578214., 674751., 578214.,
      481695., 397650., 477015., 556290., 476385., 396600., 314130.,
      376572., 438858., 375564., 312450.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11253., 11424., 11595., 11766., 11937., 12450., 12621., 12792., 12963.,
      13134., 13647., 13818., 13989., 14160., 14331., 14844., 15015., 15186.,
      15357., 15528., 16041., 16212., 16383., 16554., 16725.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      621570.,  624900.,  747096.,  751128.,  872970.,  877716.,  749040.,
      753144.,  624810.,  628260.,  788775.,  793200.,  947415.,  952770.,
      1106280., 1112580., 948585.,  954030.,  790725.,  795300.,  957765.,
      963390.,  1149624., 1156428., 1341501., 1349502., 1149516., 1156428.,
      957585.,  963390.,  790350.,  795300.,  948045.,  954030.,  1105545.,
      1112580., 946695.,  952770.,  788100.,  793200.,  624090.,  628260.,
      748104.,  753144.,  871794.,  877716.,  746016.,  751128.,  620610.,
      624900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21651., 22506., 21975., 22848., 22299., 23190., 22623., 23532., 22947.,
      23874., 23919., 24900., 24243., 25242., 24567., 25584., 24891., 25926.,
      25215., 26268., 26187., 27294., 26511., 27636., 26835., 27978., 27159.,
      28320., 27483., 28662., 28455., 29688., 28779., 30030., 29103., 30372.,
      29427., 30714., 29751., 31056., 30723., 32082., 31047., 32424., 31371.,
      32766., 31695., 33108., 32019., 33450.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1239810., 1243140., 1246470., 1249800., 1490160., 1494192., 1498224.,
      1502256., 1741194., 1745940., 1750686., 1755432., 1493976., 1498080.,
      1502184., 1506288., 1246170., 1249620., 1253070., 1256520., 1573125.,
      1577550., 1581975., 1586400., 1889475., 1894830., 1900185., 1905540.,
      2206260., 2212560., 2218860., 2225160., 1891725., 1897170., 1902615.,
      1908060., 1576875., 1581450., 1586025., 1590600., 1909905., 1915530.,
      1921155., 1926780., 2292444., 2299248., 2306052., 2312856., 2675001.,
      2683002., 2691003., 2699004., 2292120., 2299032., 2305944., 2312856.,
      1909365., 1915170., 1920975., 1926780., 1575750., 1580700., 1585650.,
      1590600., 1890105., 1896090., 1902075., 1908060., 2204055., 2211090.,
      2218125., 2225160., 1887315., 1893390., 1899465., 1905540., 1571100.,
      1576200., 1581300., 1586400., 1244010., 1248180., 1252350., 1256520.,
      1491168., 1496208., 1501248., 1506288., 1737666., 1743588., 1749510.,
      1755432., 1486920., 1492032., 1497144., 1502256., 1236930., 1241220.,
      1245510., 1249800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42447., 43302., 44157., 45012., 43077., 43950., 44823., 45696., 43707.,
      44598., 45489., 46380., 44337., 45246., 46155., 47064., 44967., 45894.,
      46821., 47748., 46857., 47838., 48819., 49800., 47487., 48486., 49485.,
      50484., 48117., 49134., 50151., 51168., 48747., 49782., 50817., 51852.,
      49377., 50430., 51483., 52536., 51267., 52374., 53481., 54588., 51897.,
      53022., 54147., 55272., 52527., 53670., 54813., 55956., 53157., 54318.,
      55479., 56640., 53787., 54966., 56145., 57324., 55677., 56910., 58143.,
      59376., 56307., 57558., 58809., 60060., 56937., 58206., 59475., 60744.,
      57567., 58854., 60141., 61428., 58197., 59502., 60807., 62112., 60087.,
      61446., 62805., 64164., 60717., 62094., 63471., 64848., 61347., 62742.,
      64137., 65532., 61977., 63390., 64803., 66216., 62607., 64038., 65469.,
      66900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      620610.,  624900.,  746016.,  751128.,  871794.,  877716.,  748104.,
      753144.,  624090.,  628260.,  788100.,  793200.,  946695.,  952770.,
      1105545., 1112580., 948045.,  954030.,  790350.,  795300.,  957585.,
      963390.,  1149516., 1156428., 1341501., 1349502., 1149624., 1156428.,
      957765.,  963390.,  790725.,  795300.,  948585.,  954030.,  1106280.,
      1112580., 947415.,  952770.,  788775.,  793200.,  624810.,  628260.,
      749040.,  753144.,  872970.,  877716.,  747096.,  751128.,  621570.,
      624900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22335., 22506., 22677., 22848., 23019., 23190., 23361., 23532., 23703.,
      23874., 24729., 24900., 25071., 25242., 25413., 25584., 25755., 25926.,
      26097., 26268., 27123., 27294., 27465., 27636., 27807., 27978., 28149.,
      28320., 28491., 28662., 29517., 29688., 29859., 30030., 30201., 30372.,
      30543., 30714., 30885., 31056., 31911., 32082., 32253., 32424., 32595.,
      32766., 32937., 33108., 33279., 33450.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1234620., 1241220., 1243140., 1249800., 1484040., 1492032., 1494192.,
      1502256., 1734180., 1743588., 1745940., 1755432., 1488072., 1496208.,
      1498080., 1506288., 1241340., 1248180., 1249620., 1256520., 1567425.,
      1576200., 1577550., 1586400., 1882770., 1893390., 1894830., 1905540.,
      2198595., 2211090., 2212560., 2225160., 1885290., 1896090., 1897170.,
      1908060., 1571625., 1580700., 1581450., 1590600., 1904010., 1915170.,
      1915530., 1926780., 2285532., 2299032., 2299248., 2312856., 2667126.,
      2683002., 2683002., 2699004., 2285532., 2299248., 2299032., 2312856.,
      1904010., 1915530., 1915170., 1926780., 1571625., 1581450., 1580700.,
      1590600., 1885290., 1897170., 1896090., 1908060., 2198595., 2212560.,
      2211090., 2225160., 1882770., 1894830., 1893390., 1905540., 1567425.,
      1577550., 1576200., 1586400., 1241340., 1249620., 1248180., 1256520.,
      1488072., 1498080., 1496208., 1506288., 1734180., 1745940., 1743588.,
      1755432., 1484040., 1494192., 1492032., 1502256., 1234620., 1243140.,
      1241220., 1249800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42978., 44670., 43302., 45012., 43626., 45354., 43950., 45696., 44274.,
      46038., 44598., 46380., 44922., 46722., 45246., 47064., 45570., 47406.,
      45894., 47748., 47514., 49458., 47838., 49800., 48162., 50142., 48486.,
      50484., 48810., 50826., 49134., 51168., 49458., 51510., 49782., 51852.,
      50106., 52194., 50430., 52536., 52050., 54246., 52374., 54588., 52698.,
      54930., 53022., 55272., 53346., 55614., 53670., 55956., 53994., 56298.,
      54318., 56640., 54642., 56982., 54966., 57324., 56586., 59034., 56910.,
      59376., 57234., 59718., 57558., 60060., 57882., 60402., 58206., 60744.,
      58530., 61086., 58854., 61428., 59178., 61770., 59502., 62112., 61122.,
      63822., 61446., 64164., 61770., 64506., 62094., 64848., 62418., 65190.,
      62742., 65532., 63066., 65874., 63390., 66216., 63714., 66558., 64038.,
      66900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2462640., 2469240., 2475840., 2482440., 2479620., 2486280., 2492940.,
      2499600., 2960088., 2968080., 2976072., 2984064., 2980320., 2988384.,
      2996448., 3004512., 3458952., 3468360., 3477768., 3487176., 3482388.,
      3491880., 3501372., 3510864., 2968008., 2976144., 2984280., 2992416.,
      2987952., 2996160., 3004368., 3012576., 2475840., 2482680., 2489520.,
      2496360., 2492340., 2499240., 2506140., 2513040., 3126075., 3134850.,
      3143625., 3152400., 3146250., 3155100., 3163950., 3172800., 3754920.,
      3765540., 3776160., 3786780., 3778950., 3789660., 3800370., 3811080.,
      4384695., 4397190., 4409685., 4422180., 4412520., 4425120., 4437720.,
      4450320., 3759780., 3770580., 3781380., 3792180., 3783450., 3794340.,
      3805230., 3816120., 3134175., 3143250., 3152325., 3161400., 3153750.,
      3162900., 3172050., 3181200., 3796860., 3808020., 3819180., 3830340.,
      3819810., 3831060., 3842310., 3853560., 4557564., 4571064., 4584564.,
      4598064., 4584888., 4598496., 4612104., 4625712., 5318376., 5334252.,
      5350128., 5366004., 5350002., 5366004., 5382006., 5398008., 4557348.,
      4571064., 4584780., 4598496., 4584240., 4598064., 4611888., 4625712.,
      3796500., 3808020., 3819540., 3831060., 3818730., 3830340., 3841950.,
      3853560., 3133425., 3143250., 3153075., 3162900., 3151500., 3161400.,
      3171300., 3181200., 3758700., 3770580., 3782460., 3794340., 3780210.,
      3792180., 3804150., 3816120., 4383225., 4397190., 4411155., 4425120.,
      4408110., 4422180., 4436250., 4450320., 3753480., 3765540., 3777600.,
      3789660., 3774630., 3786780., 3798930., 3811080., 3124725., 3134850.,
      3144975., 3155100., 3142200., 3152400., 3162600., 3172800., 2474400.,
      2482680., 2490960., 2499240., 2488020., 2496360., 2504700., 2513040.,
      2966136., 2976144., 2986152., 2996160., 2982336., 2992416., 3002496.,
      3012576., 3456600., 3468360., 3480120., 3491880., 3475332., 3487176.,
      3499020., 3510864., 2957928., 2968080., 2978232., 2988384., 2973840.,
      2984064., 2994288., 3004512., 2460720., 2469240., 2477760., 2486280.,
      2473860., 2482440., 2491020., 2499600.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      84264.,  85956.,  87648.,  89340.,  84894.,  86604.,  88314.,  90024.,
      85524.,  87252.,  88980.,  90708.,  86154.,  87900.,  89646.,  91392.,
      86784.,  88548.,  90312.,  92076.,  87414.,  89196.,  90978.,  92760.,
      88044.,  89844.,  91644.,  93444.,  88674.,  90492.,  92310.,  94128.,
      89304.,  91140.,  92976.,  94812.,  89934.,  91788.,  93642.,  95496.,
      93084.,  95028.,  96972.,  98916.,  93714.,  95676.,  97638.,  99600.,
      94344.,  96324.,  98304.,  100284., 94974.,  96972.,  98970.,  100968.,
      95604.,  97620.,  99636.,  101652., 96234.,  98268.,  100302., 102336.,
      96864.,  98916.,  100968., 103020., 97494.,  99564.,  101634., 103704.,
      98124.,  100212., 102300., 104388., 98754.,  100860., 102966., 105072.,
      101904., 104100., 106296., 108492., 102534., 104748., 106962., 109176.,
      103164., 105396., 107628., 109860., 103794., 106044., 108294., 110544.,
      104424., 106692., 108960., 111228., 105054., 107340., 109626., 111912.,
      105684., 107988., 110292., 112596., 106314., 108636., 110958., 113280.,
      106944., 109284., 111624., 113964., 107574., 109932., 112290., 114648.,
      110724., 113172., 115620., 118068., 111354., 113820., 116286., 118752.,
      111984., 114468., 116952., 119436., 112614., 115116., 117618., 120120.,
      113244., 115764., 118284., 120804., 113874., 116412., 118950., 121488.,
      114504., 117060., 119616., 122172., 115134., 117708., 120282., 122856.,
      115764., 118356., 120948., 123540., 116394., 119004., 121614., 124224.,
      119544., 122244., 124944., 127644., 120174., 122892., 125610., 128328.,
      120804., 123540., 126276., 129012., 121434., 124188., 126942., 129696.,
      122064., 124836., 127608., 130380., 122694., 125484., 128274., 131064.,
      123324., 126132., 128940., 131748., 123954., 126780., 129606., 132432.,
      124584., 127428., 130272., 133116., 125214., 128076., 130938., 133800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1236930., 1241220., 1245510., 1249800., 1486920., 1492032., 1497144.,
      1502256., 1737666., 1743588., 1749510., 1755432., 1491168., 1496208.,
      1501248., 1506288., 1244010., 1248180., 1252350., 1256520., 1571100.,
      1576200., 1581300., 1586400., 1887315., 1893390., 1899465., 1905540.,
      2204055., 2211090., 2218125., 2225160., 1890105., 1896090., 1902075.,
      1908060., 1575750., 1580700., 1585650., 1590600., 1909365., 1915170.,
      1920975., 1926780., 2292120., 2299032., 2305944., 2312856., 2675001.,
      2683002., 2691003., 2699004., 2292444., 2299248., 2306052., 2312856.,
      1909905., 1915530., 1921155., 1926780., 1576875., 1581450., 1586025.,
      1590600., 1891725., 1897170., 1902615., 1908060., 2206260., 2212560.,
      2218860., 2225160., 1889475., 1894830., 1900185., 1905540., 1573125.,
      1577550., 1581975., 1586400., 1246170., 1249620., 1253070., 1256520.,
      1493976., 1498080., 1502184., 1506288., 1741194., 1745940., 1750686.,
      1755432., 1490160., 1494192., 1498224., 1502256., 1239810., 1243140.,
      1246470., 1249800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44499., 44670., 44841., 45012., 45183., 45354., 45525., 45696., 45867.,
      46038., 46209., 46380., 46551., 46722., 46893., 47064., 47235., 47406.,
      47577., 47748., 49287., 49458., 49629., 49800., 49971., 50142., 50313.,
      50484., 50655., 50826., 50997., 51168., 51339., 51510., 51681., 51852.,
      52023., 52194., 52365., 52536., 54075., 54246., 54417., 54588., 54759.,
      54930., 55101., 55272., 55443., 55614., 55785., 55956., 56127., 56298.,
      56469., 56640., 56811., 56982., 57153., 57324., 58863., 59034., 59205.,
      59376., 59547., 59718., 59889., 60060., 60231., 60402., 60573., 60744.,
      60915., 61086., 61257., 61428., 61599., 61770., 61941., 62112., 63651.,
      63822., 63993., 64164., 64335., 64506., 64677., 64848., 65019., 65190.,
      65361., 65532., 65703., 65874., 66045., 66216., 66387., 66558., 66729.,
      66900.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2460720., 2473860., 2469240., 2482440., 2477760., 2491020., 2486280.,
      2499600., 2957928., 2973840., 2968080., 2984064., 2978232., 2994288.,
      2988384., 3004512., 3456600., 3475332., 3468360., 3487176., 3480120.,
      3499020., 3491880., 3510864., 2966136., 2982336., 2976144., 2992416.,
      2986152., 3002496., 2996160., 3012576., 2474400., 2488020., 2482680.,
      2496360., 2490960., 2504700., 2499240., 2513040., 3124725., 3142200.,
      3134850., 3152400., 3144975., 3162600., 3155100., 3172800., 3753480.,
      3774630., 3765540., 3786780., 3777600., 3798930., 3789660., 3811080.,
      4383225., 4408110., 4397190., 4422180., 4411155., 4436250., 4425120.,
      4450320., 3758700., 3780210., 3770580., 3792180., 3782460., 3804150.,
      3794340., 3816120., 3133425., 3151500., 3143250., 3161400., 3153075.,
      3171300., 3162900., 3181200., 3796500., 3818730., 3808020., 3830340.,
      3819540., 3841950., 3831060., 3853560., 4557348., 4584240., 4571064.,
      4598064., 4584780., 4611888., 4598496., 4625712., 5318376., 5350002.,
      5334252., 5366004., 5350128., 5382006., 5366004., 5398008., 4557564.,
      4584888., 4571064., 4598496., 4584564., 4612104., 4598064., 4625712.,
      3796860., 3819810., 3808020., 3831060., 3819180., 3842310., 3830340.,
      3853560., 3134175., 3153750., 3143250., 3162900., 3152325., 3172050.,
      3161400., 3181200., 3759780., 3783450., 3770580., 3794340., 3781380.,
      3805230., 3792180., 3816120., 4384695., 4412520., 4397190., 4425120.,
      4409685., 4437720., 4422180., 4450320., 3754920., 3778950., 3765540.,
      3789660., 3776160., 3800370., 3786780., 3811080., 3126075., 3146250.,
      3134850., 3155100., 3143625., 3163950., 3152400., 3172800., 2475840.,
      2492340., 2482680., 2499240., 2489520., 2506140., 2496360., 2513040.,
      2968008., 2987952., 2976144., 2996160., 2984280., 3004368., 2992416.,
      3012576., 3458952., 3482388., 3468360., 3491880., 3477768., 3501372.,
      3487176., 3510864., 2960088., 2980320., 2968080., 2988384., 2976072.,
      2996448., 2984064., 3004512., 2462640., 2479620., 2469240., 2486280.,
      2475840., 2492940., 2482440., 2499600.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      85632.,  88998.,  85956.,  89340.,  86280.,  89682.,  86604.,  90024.,
      86928.,  90366.,  87252.,  90708.,  87576.,  91050.,  87900.,  91392.,
      88224.,  91734.,  88548.,  92076.,  88872.,  92418.,  89196.,  92760.,
      89520.,  93102.,  89844.,  93444.,  90168.,  93786.,  90492.,  94128.,
      90816.,  94470.,  91140.,  94812.,  91464.,  95154.,  91788.,  95496.,
      94704.,  98574.,  95028.,  98916.,  95352.,  99258.,  95676.,  99600.,
      96000.,  99942.,  96324.,  100284., 96648.,  100626., 96972.,  100968.,
      97296.,  101310., 97620.,  101652., 97944.,  101994., 98268.,  102336.,
      98592.,  102678., 98916.,  103020., 99240.,  103362., 99564.,  103704.,
      99888.,  104046., 100212., 104388., 100536., 104730., 100860., 105072.,
      103776., 108150., 104100., 108492., 104424., 108834., 104748., 109176.,
      105072., 109518., 105396., 109860., 105720., 110202., 106044., 110544.,
      106368., 110886., 106692., 111228., 107016., 111570., 107340., 111912.,
      107664., 112254., 107988., 112596., 108312., 112938., 108636., 113280.,
      108960., 113622., 109284., 113964., 109608., 114306., 109932., 114648.,
      112848., 117726., 113172., 118068., 113496., 118410., 113820., 118752.,
      114144., 119094., 114468., 119436., 114792., 119778., 115116., 120120.,
      115440., 120462., 115764., 120804., 116088., 121146., 116412., 121488.,
      116736., 121830., 117060., 122172., 117384., 122514., 117708., 122856.,
      118032., 123198., 118356., 123540., 118680., 123882., 119004., 124224.,
      121920., 127302., 122244., 127644., 122568., 127986., 122892., 128328.,
      123216., 128670., 123540., 129012., 123864., 129354., 124188., 129696.,
      124512., 130038., 124836., 130380., 125160., 130722., 125484., 131064.,
      125808., 131406., 126132., 131748., 126456., 132090., 126780., 132432.,
      127104., 132774., 127428., 133116., 127752., 133458., 128076., 133800.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4908300.,  4921440.,  4934580.,  4947720.,  4925280.,  4938480.,
      4951680.,  4964880.,  4942260.,  4955520.,  4968780.,  4982040.,
      4959240.,  4972560.,  4985880.,  4999200.,  5899944.,  5915856.,
      5931768.,  5947680.,  5920176.,  5936160.,  5952144.,  5968128.,
      5940408.,  5956464.,  5972520.,  5988576.,  5960640.,  5976768.,
      5992896.,  6009024.,  6894468.,  6913200.,  6931932.,  6950664.,
      6917904.,  6936720.,  6955536.,  6974352.,  6941340.,  6960240.,
      6979140.,  6998040.,  6964776.,  6983760.,  7002744.,  7021728.,
      5916072.,  5932272.,  5948472.,  5964672.,  5936016.,  5952288.,
      5968560.,  5984832.,  5955960.,  5972304.,  5988648.,  6004992.,
      5975904.,  5992320.,  6008736.,  6025152.,  4935180.,  4948800.,
      4962420.,  4976040.,  4951680.,  4965360.,  4979040.,  4992720.,
      4968180.,  4981920.,  4995660.,  5009400.,  4984680.,  4998480.,
      5012280.,  5026080.,  6231975.,  6249450.,  6266925.,  6284400.,
      6252150.,  6269700.,  6287250.,  6304800.,  6272325.,  6289950.,
      6307575.,  6325200.,  6292500.,  6310200.,  6327900.,  6345600.,
      7485810.,  7506960.,  7528110.,  7549260.,  7509840.,  7531080.,
      7552320.,  7573560.,  7533870.,  7555200.,  7576530.,  7597860.,
      7557900.,  7579320.,  7600740.,  7622160.,  8741565.,  8766450.,
      8791335.,  8816220.,  8769390.,  8794380.,  8819370.,  8844360.,
      8797215.,  8822310.,  8847405.,  8872500.,  8825040.,  8850240.,
      8875440.,  8900640.,  7495890.,  7517400.,  7538910.,  7560420.,
      7519560.,  7541160.,  7562760.,  7584360.,  7543230.,  7564920.,
      7586610.,  7608300.,  7566900.,  7588680.,  7610460.,  7632240.,
      6248775.,  6266850.,  6284925.,  6303000.,  6268350.,  6286500.,
      6304650.,  6322800.,  6287925.,  6306150.,  6324375.,  6342600.,
      6307500.,  6325800.,  6344100.,  6362400.,  7570770.,  7593000.,
      7615230.,  7637460.,  7593720.,  7616040.,  7638360.,  7660680.,
      7616670.,  7639080.,  7661490.,  7683900.,  7639620.,  7662120.,
      7684620.,  7707120.,  9087804.,  9114696.,  9141588.,  9168480.,
      9115128.,  9142128.,  9169128.,  9196128.,  9142452.,  9169560.,
      9196668.,  9223776.,  9169776.,  9196992.,  9224208.,  9251424.,
      10605126., 10636752., 10668378., 10700004., 10636752., 10668504.,
      10700256., 10732008., 10668378., 10700256., 10732134., 10764012.,
      10700004., 10732008., 10764012., 10796016., 9087804.,  9115128.,
      9142452.,  9169776.,  9114696.,  9142128.,  9169560.,  9196992.,
      9141588.,  9169128.,  9196668.,  9224208.,  9168480.,  9196128.,
      9223776.,  9251424.,  7570770.,  7593720.,  7616670.,  7639620.,
      7593000.,  7616040.,  7639080.,  7662120.,  7615230.,  7638360.,
      7661490.,  7684620.,  7637460.,  7660680.,  7683900.,  7707120.,
      6248775.,  6268350.,  6287925.,  6307500.,  6266850.,  6286500.,
      6306150.,  6325800.,  6284925.,  6304650.,  6324375.,  6344100.,
      6303000.,  6322800.,  6342600.,  6362400.,  7495890.,  7519560.,
      7543230.,  7566900.,  7517400.,  7541160.,  7564920.,  7588680.,
      7538910.,  7562760.,  7586610.,  7610460.,  7560420.,  7584360.,
      7608300.,  7632240.,  8741565.,  8769390.,  8797215.,  8825040.,
      8766450.,  8794380.,  8822310.,  8850240.,  8791335.,  8819370.,
      8847405.,  8875440.,  8816220.,  8844360.,  8872500.,  8900640.,
      7485810.,  7509840.,  7533870.,  7557900.,  7506960.,  7531080.,
      7555200.,  7579320.,  7528110.,  7552320.,  7576530.,  7600740.,
      7549260.,  7573560.,  7597860.,  7622160.,  6231975.,  6252150.,
      6272325.,  6292500.,  6249450.,  6269700.,  6289950.,  6310200.,
      6266925.,  6287250.,  6307575.,  6327900.,  6284400.,  6304800.,
      6325200.,  6345600.,  4935180.,  4951680.,  4968180.,  4984680.,
      4948800.,  4965360.,  4981920.,  4998480.,  4962420.,  4979040.,
      4995660.,  5012280.,  4976040.,  4992720.,  5009400.,  5026080.,
      5916072.,  5936016.,  5955960.,  5975904.,  5932272.,  5952288.,
      5972304.,  5992320.,  5948472.,  5968560.,  5988648.,  6008736.,
      5964672.,  5984832.,  6004992.,  6025152.,  6894468.,  6917904.,
      6941340.,  6964776.,  6913200.,  6936720.,  6960240.,  6983760.,
      6931932.,  6955536.,  6979140.,  7002744.,  6950664.,  6974352.,
      6998040.,  7021728.,  5899944.,  5920176.,  5940408.,  5960640.,
      5915856.,  5936160.,  5956464.,  5976768.,  5931768.,  5952144.,
      5972520.,  5992896.,  5947680.,  5968128.,  5988576.,  6009024.,
      4908300.,  4925280.,  4942260.,  4959240.,  4921440.,  4938480.,
      4955520.,  4972560.,  4934580.,  4951680.,  4968780.,  4985880.,
      4947720.,  4964880.,  4982040.,  4999200.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      167898., 171264., 174630., 177996., 168528., 171912., 175296., 178680.,
      169158., 172560., 175962., 179364., 169788., 173208., 176628., 180048.,
      170418., 173856., 177294., 180732., 171048., 174504., 177960., 181416.,
      171678., 175152., 178626., 182100., 172308., 175800., 179292., 182784.,
      172938., 176448., 179958., 183468., 173568., 177096., 180624., 184152.,
      174198., 177744., 181290., 184836., 174828., 178392., 181956., 185520.,
      175458., 179040., 182622., 186204., 176088., 179688., 183288., 186888.,
      176718., 180336., 183954., 187572., 177348., 180984., 184620., 188256.,
      177978., 181632., 185286., 188940., 178608., 182280., 185952., 189624.,
      179238., 182928., 186618., 190308., 179868., 183576., 187284., 190992.,
      185538., 189408., 193278., 197148., 186168., 190056., 193944., 197832.,
      186798., 190704., 194610., 198516., 187428., 191352., 195276., 199200.,
      188058., 192000., 195942., 199884., 188688., 192648., 196608., 200568.,
      189318., 193296., 197274., 201252., 189948., 193944., 197940., 201936.,
      190578., 194592., 198606., 202620., 191208., 195240., 199272., 203304.,
      191838., 195888., 199938., 203988., 192468., 196536., 200604., 204672.,
      193098., 197184., 201270., 205356., 193728., 197832., 201936., 206040.,
      194358., 198480., 202602., 206724., 194988., 199128., 203268., 207408.,
      195618., 199776., 203934., 208092., 196248., 200424., 204600., 208776.,
      196878., 201072., 205266., 209460., 197508., 201720., 205932., 210144.,
      203178., 207552., 211926., 216300., 203808., 208200., 212592., 216984.,
      204438., 208848., 213258., 217668., 205068., 209496., 213924., 218352.,
      205698., 210144., 214590., 219036., 206328., 210792., 215256., 219720.,
      206958., 211440., 215922., 220404., 207588., 212088., 216588., 221088.,
      208218., 212736., 217254., 221772., 208848., 213384., 217920., 222456.,
      209478., 214032., 218586., 223140., 210108., 214680., 219252., 223824.,
      210738., 215328., 219918., 224508., 211368., 215976., 220584., 225192.,
      211998., 216624., 221250., 225876., 212628., 217272., 221916., 226560.,
      213258., 217920., 222582., 227244., 213888., 218568., 223248., 227928.,
      214518., 219216., 223914., 228612., 215148., 219864., 224580., 229296.,
      220818., 225696., 230574., 235452., 221448., 226344., 231240., 236136.,
      222078., 226992., 231906., 236820., 222708., 227640., 232572., 237504.,
      223338., 228288., 233238., 238188., 223968., 228936., 233904., 238872.,
      224598., 229584., 234570., 239556., 225228., 230232., 235236., 240240.,
      225858., 230880., 235902., 240924., 226488., 231528., 236568., 241608.,
      227118., 232176., 237234., 242292., 227748., 232824., 237900., 242976.,
      228378., 233472., 238566., 243660., 229008., 234120., 239232., 244344.,
      229638., 234768., 239898., 245028., 230268., 235416., 240564., 245712.,
      230898., 236064., 241230., 246396., 231528., 236712., 241896., 247080.,
      232158., 237360., 242562., 247764., 232788., 238008., 243228., 248448.,
      238458., 243840., 249222., 254604., 239088., 244488., 249888., 255288.,
      239718., 245136., 250554., 255972., 240348., 245784., 251220., 256656.,
      240978., 246432., 251886., 257340., 241608., 247080., 252552., 258024.,
      242238., 247728., 253218., 258708., 242868., 248376., 253884., 259392.,
      243498., 249024., 254550., 260076., 244128., 249672., 255216., 260760.,
      244758., 250320., 255882., 261444., 245388., 250968., 256548., 262128.,
      246018., 251616., 257214., 262812., 246648., 252264., 257880., 263496.,
      247278., 252912., 258546., 264180., 247908., 253560., 259212., 264864.,
      248538., 254208., 259878., 265548., 249168., 254856., 260544., 266232.,
      249798., 255504., 261210., 266916., 250428., 256152., 261876., 267600.};
  const std::array<int, 4> in_shape = {{3, 6, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      489180., 571536., 654096., 572880., 491484., 620835.,  724920.,
      829140., 725760., 622275., 753930., 879816., 1005720., 879816.,
      753930., 622275., 725760., 829140., 724920., 620835.,  491484.,
      572880., 654096., 571536., 489180.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22716., 23016., 23316., 23616., 23916., 25116., 25416., 25716., 26016.,
      26316., 27516., 27816., 28116., 28416., 28716., 29916., 30216., 30516.,
      30816., 31116., 32316., 32616., 32916., 33216., 33516.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      973788.,  978360.,  1137696., 1143072., 1302000., 1308192., 1140300.,
      1145760., 978252.,  982968.,  1235595., 1241670., 1442700., 1449840.,
      1650060., 1658280., 1444275., 1451520., 1238295., 1244550., 1500138.,
      1507860., 1750560., 1759632., 2001000., 2011440., 1750434., 1759632.,
      1499922., 1507860., 1237755., 1244550., 1443540., 1451520., 1649100.,
      1658280., 1441755., 1449840., 1234695., 1241670., 977244.,  982968.,
      1139040., 1145760., 1300464., 1308192., 1136268., 1143072., 972492.,
      978360.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44124., 45432., 44700., 46032., 45276., 46632., 45852., 47232., 46428.,
      47832., 48732., 50232., 49308., 50832., 49884., 51432., 50460., 52032.,
      51036., 52632., 53340., 55032., 53916., 55632., 54492., 56232., 55068.,
      56832., 55644., 57432., 57948., 59832., 58524., 60432., 59100., 61032.,
      59676., 61632., 60252., 62232., 62556., 64632., 63132., 65232., 63708.,
      65832., 64284., 66432., 64860., 67032.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1943004., 1947576., 1952148., 1956720., 2270016., 2275392., 2280768.,
      2286144., 2597808., 2604000., 2610192., 2616384., 2275140., 2280600.,
      2286060., 2291520., 1951788., 1956504., 1961220., 1965936., 2465115.,
      2471190., 2477265., 2483340., 2878260., 2885400., 2892540., 2899680.,
      3291900., 3300120., 3308340., 3316560., 2881305., 2888550., 2895795.,
      2903040., 2470335., 2476590., 2482845., 2489100., 2992554., 3000276.,
      3007998., 3015720., 3492048., 3501120., 3510192., 3519264., 3991560.,
      4002000., 4012440., 4022880., 3491670., 3500868., 3510066., 3519264.,
      2991906., 2999844., 3007782., 3015720., 2468715., 2475510., 2482305.,
      2489100., 2879100., 2887080., 2895060., 2903040., 3289020., 3298200.,
      3307380., 3316560., 2875425., 2883510., 2891595., 2899680., 2462415.,
      2469390., 2476365., 2483340., 1948764., 1954488., 1960212., 1965936.,
      2271360., 2278080., 2284800., 2291520., 2593200., 2600928., 2608656.,
      2616384., 2265732., 2272536., 2279340., 2286144., 1939116., 1944984.,
      1950852., 1956720.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86940.,  88248.,  89556.,  90864.,  88068.,  89400.,  90732.,  92064.,
      89196.,  90552.,  91908.,  93264.,  90324.,  91704.,  93084.,  94464.,
      91452.,  92856.,  94260.,  95664.,  95964.,  97464.,  98964.,  100464.,
      97092.,  98616.,  100140., 101664., 98220.,  99768.,  101316., 102864.,
      99348.,  100920., 102492., 104064., 100476., 102072., 103668., 105264.,
      104988., 106680., 108372., 110064., 106116., 107832., 109548., 111264.,
      107244., 108984., 110724., 112464., 108372., 110136., 111900., 113664.,
      109500., 111288., 113076., 114864., 114012., 115896., 117780., 119664.,
      115140., 117048., 118956., 120864., 116268., 118200., 120132., 122064.,
      117396., 119352., 121308., 123264., 118524., 120504., 122484., 124464.,
      123036., 125112., 127188., 129264., 124164., 126264., 128364., 130464.,
      125292., 127416., 129540., 131664., 126420., 128568., 130716., 132864.,
      127548., 129720., 131892., 134064.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      972492.,  978360.,  1136268., 1143072., 1300464., 1308192., 1139040.,
      1145760., 977244.,  982968.,  1234695., 1241670., 1441755., 1449840.,
      1649100., 1658280., 1443540., 1451520., 1237755., 1244550., 1499922.,
      1507860., 1750434., 1759632., 2001000., 2011440., 1750560., 1759632.,
      1500138., 1507860., 1238295., 1244550., 1444275., 1451520., 1650060.,
      1658280., 1442700., 1449840., 1235595., 1241670., 978252.,  982968.,
      1140300., 1145760., 1302000., 1308192., 1137696., 1143072., 973788.,
      978360.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45132., 45432., 45732., 46032., 46332., 46632., 46932., 47232., 47532.,
      47832., 49932., 50232., 50532., 50832., 51132., 51432., 51732., 52032.,
      52332., 52632., 54732., 55032., 55332., 55632., 55932., 56232., 56532.,
      56832., 57132., 57432., 59532., 59832., 60132., 60432., 60732., 61032.,
      61332., 61632., 61932., 62232., 64332., 64632., 64932., 65232., 65532.,
      65832., 66132., 66432., 66732., 67032.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1935912., 1944984., 1947576., 1956720., 2261868., 2272536., 2275392.,
      2286144., 2588640., 2600928., 2604000., 2616384., 2267244., 2278080.,
      2280600., 2291520., 1945128., 1954488., 1956504., 1965936., 2457330.,
      2469390., 2471190., 2483340., 2869335., 2883510., 2885400., 2899680.,
      3281880., 3298200., 3300120., 3316560., 2872695., 2887080., 2888550.,
      2903040., 2463090., 2475510., 2476590., 2489100., 2984508., 2999844.,
      3000276., 3015720., 3482850., 3500868., 3501120., 3519264., 3981264.,
      4002000., 4002000., 4022880., 3482850., 3501120., 3500868., 3519264.,
      2984508., 3000276., 2999844., 3015720., 2463090., 2476590., 2475510.,
      2489100., 2872695., 2888550., 2887080., 2903040., 3281880., 3300120.,
      3298200., 3316560., 2869335., 2885400., 2883510., 2899680., 2457330.,
      2471190., 2469390., 2483340., 1945128., 1956504., 1954488., 1965936.,
      2267244., 2280600., 2278080., 2291520., 2588640., 2604000., 2600928.,
      2616384., 2261868., 2275392., 2272536., 2286144., 1935912., 1947576.,
      1944984., 1956720.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87672.,  90264.,  88248.,  90864.,  88824.,  91464.,  89400.,  92064.,
      89976.,  92664.,  90552.,  93264.,  91128.,  93864.,  91704.,  94464.,
      92280.,  95064.,  92856.,  95664.,  96888.,  99864.,  97464.,  100464.,
      98040.,  101064., 98616.,  101664., 99192.,  102264., 99768.,  102864.,
      100344., 103464., 100920., 104064., 101496., 104664., 102072., 105264.,
      106104., 109464., 106680., 110064., 107256., 110664., 107832., 111264.,
      108408., 111864., 108984., 112464., 109560., 113064., 110136., 113664.,
      110712., 114264., 111288., 114864., 115320., 119064., 115896., 119664.,
      116472., 120264., 117048., 120864., 117624., 121464., 118200., 122064.,
      118776., 122664., 119352., 123264., 119928., 123864., 120504., 124464.,
      124536., 128664., 125112., 129264., 125688., 129864., 126264., 130464.,
      126840., 131064., 127416., 131664., 127992., 132264., 128568., 132864.,
      129144., 133464., 129720., 134064.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3862752., 3871824., 3880896., 3889968., 3886008., 3895152., 3904296.,
      3913440., 4513068., 4523736., 4534404., 4545072., 4540032., 4550784.,
      4561536., 4572288., 5164992., 5177280., 5189568., 5201856., 5195616.,
      5208000., 5220384., 5232768., 4523652., 4534488., 4545324., 4556160.,
      4550280., 4561200., 4572120., 4583040., 3880896., 3890256., 3899616.,
      3908976., 3903576., 3913008., 3922440., 3931872., 4902600., 4914660.,
      4926720., 4938780., 4930230., 4942380., 4954530., 4966680., 5724495.,
      5738670., 5752845., 5767020., 5756520., 5770800., 5785080., 5799360.,
      6547440., 6563760., 6580080., 6596400., 6583800., 6600240., 6616680.,
      6633120., 5731005., 5745390., 5759775., 5774160., 5762610., 5777100.,
      5791590., 5806080., 4913760., 4926180., 4938600., 4951020., 4940670.,
      4953180., 4965690., 4978200., 5953680., 5969016., 5984352., 5999688.,
      5985108., 6000552., 6015996., 6031440., 6947682., 6965700., 6983718.,
      7001736., 6984096., 7002240., 7020384., 7038528., 7941792., 7962528.,
      7983264., 8004000., 7983120., 8004000., 8024880., 8045760., 6947430.,
      6965700., 6983970., 7002240., 6983340., 7001736., 7020132., 7038528.,
      5953248., 5969016., 5984784., 6000552., 5983812., 5999688., 6015564.,
      6031440., 4912680., 4926180., 4939680., 4953180., 4937430., 4951020.,
      4964610., 4978200., 5729535., 5745390., 5761245., 5777100., 5758200.,
      5774160., 5790120., 5806080., 6545520., 6563760., 6582000., 6600240.,
      6578040., 6596400., 6614760., 6633120., 5722605., 5738670., 5754735.,
      5770800., 5750850., 5767020., 5783190., 5799360., 4900800., 4914660.,
      4928520., 4942380., 4924830., 4938780., 4952730., 4966680., 3878880.,
      3890256., 3901632., 3913008., 3897528., 3908976., 3920424., 3931872.,
      4521132., 4534488., 4547844., 4561200., 4542720., 4556160., 4569600.,
      4583040., 5161920., 5177280., 5192640., 5208000., 5186400., 5201856.,
      5217312., 5232768., 4510212., 4523736., 4537260., 4550784., 4531464.,
      4545072., 4558680., 4572288., 3860160., 3871824., 3883488., 3895152.,
      3878232., 3889968., 3901704., 3913440.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      172752., 175344., 177936., 180528., 173880., 176496., 179112., 181728.,
      175008., 177648., 180288., 182928., 176136., 178800., 181464., 184128.,
      177264., 179952., 182640., 185328., 178392., 181104., 183816., 186528.,
      179520., 182256., 184992., 187728., 180648., 183408., 186168., 188928.,
      181776., 184560., 187344., 190128., 182904., 185712., 188520., 191328.,
      190800., 193776., 196752., 199728., 191928., 194928., 197928., 200928.,
      193056., 196080., 199104., 202128., 194184., 197232., 200280., 203328.,
      195312., 198384., 201456., 204528., 196440., 199536., 202632., 205728.,
      197568., 200688., 203808., 206928., 198696., 201840., 204984., 208128.,
      199824., 202992., 206160., 209328., 200952., 204144., 207336., 210528.,
      208848., 212208., 215568., 218928., 209976., 213360., 216744., 220128.,
      211104., 214512., 217920., 221328., 212232., 215664., 219096., 222528.,
      213360., 216816., 220272., 223728., 214488., 217968., 221448., 224928.,
      215616., 219120., 222624., 226128., 216744., 220272., 223800., 227328.,
      217872., 221424., 224976., 228528., 219000., 222576., 226152., 229728.,
      226896., 230640., 234384., 238128., 228024., 231792., 235560., 239328.,
      229152., 232944., 236736., 240528., 230280., 234096., 237912., 241728.,
      231408., 235248., 239088., 242928., 232536., 236400., 240264., 244128.,
      233664., 237552., 241440., 245328., 234792., 238704., 242616., 246528.,
      235920., 239856., 243792., 247728., 237048., 241008., 244968., 248928.,
      244944., 249072., 253200., 257328., 246072., 250224., 254376., 258528.,
      247200., 251376., 255552., 259728., 248328., 252528., 256728., 260928.,
      249456., 253680., 257904., 262128., 250584., 254832., 259080., 263328.,
      251712., 255984., 260256., 264528., 252840., 257136., 261432., 265728.,
      253968., 258288., 262608., 266928., 255096., 259440., 263784., 268128.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1939116., 1944984., 1950852., 1956720., 2265732., 2272536., 2279340.,
      2286144., 2593200., 2600928., 2608656., 2616384., 2271360., 2278080.,
      2284800., 2291520., 1948764., 1954488., 1960212., 1965936., 2462415.,
      2469390., 2476365., 2483340., 2875425., 2883510., 2891595., 2899680.,
      3289020., 3298200., 3307380., 3316560., 2879100., 2887080., 2895060.,
      2903040., 2468715., 2475510., 2482305., 2489100., 2991906., 2999844.,
      3007782., 3015720., 3491670., 3500868., 3510066., 3519264., 3991560.,
      4002000., 4012440., 4022880., 3492048., 3501120., 3510192., 3519264.,
      2992554., 3000276., 3007998., 3015720., 2470335., 2476590., 2482845.,
      2489100., 2881305., 2888550., 2895795., 2903040., 3291900., 3300120.,
      3308340., 3316560., 2878260., 2885400., 2892540., 2899680., 2465115.,
      2471190., 2477265., 2483340., 1951788., 1956504., 1961220., 1965936.,
      2275140., 2280600., 2286060., 2291520., 2597808., 2604000., 2610192.,
      2616384., 2270016., 2275392., 2280768., 2286144., 1943004., 1947576.,
      1952148., 1956720.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89964.,  90264.,  90564.,  90864.,  91164.,  91464.,  91764.,  92064.,
      92364.,  92664.,  92964.,  93264.,  93564.,  93864.,  94164.,  94464.,
      94764.,  95064.,  95364.,  95664.,  99564.,  99864.,  100164., 100464.,
      100764., 101064., 101364., 101664., 101964., 102264., 102564., 102864.,
      103164., 103464., 103764., 104064., 104364., 104664., 104964., 105264.,
      109164., 109464., 109764., 110064., 110364., 110664., 110964., 111264.,
      111564., 111864., 112164., 112464., 112764., 113064., 113364., 113664.,
      113964., 114264., 114564., 114864., 118764., 119064., 119364., 119664.,
      119964., 120264., 120564., 120864., 121164., 121464., 121764., 122064.,
      122364., 122664., 122964., 123264., 123564., 123864., 124164., 124464.,
      128364., 128664., 128964., 129264., 129564., 129864., 130164., 130464.,
      130764., 131064., 131364., 131664., 131964., 132264., 132564., 132864.,
      133164., 133464., 133764., 134064.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3860160., 3878232., 3871824., 3889968., 3883488., 3901704., 3895152.,
      3913440., 4510212., 4531464., 4523736., 4545072., 4537260., 4558680.,
      4550784., 4572288., 5161920., 5186400., 5177280., 5201856., 5192640.,
      5217312., 5208000., 5232768., 4521132., 4542720., 4534488., 4556160.,
      4547844., 4569600., 4561200., 4583040., 3878880., 3897528., 3890256.,
      3908976., 3901632., 3920424., 3913008., 3931872., 4900800., 4924830.,
      4914660., 4938780., 4928520., 4952730., 4942380., 4966680., 5722605.,
      5750850., 5738670., 5767020., 5754735., 5783190., 5770800., 5799360.,
      6545520., 6578040., 6563760., 6596400., 6582000., 6614760., 6600240.,
      6633120., 5729535., 5758200., 5745390., 5774160., 5761245., 5790120.,
      5777100., 5806080., 4912680., 4937430., 4926180., 4951020., 4939680.,
      4964610., 4953180., 4978200., 5953248., 5983812., 5969016., 5999688.,
      5984784., 6015564., 6000552., 6031440., 6947430., 6983340., 6965700.,
      7001736., 6983970., 7020132., 7002240., 7038528., 7941792., 7983120.,
      7962528., 8004000., 7983264., 8024880., 8004000., 8045760., 6947682.,
      6984096., 6965700., 7002240., 6983718., 7020384., 7001736., 7038528.,
      5953680., 5985108., 5969016., 6000552., 5984352., 6015996., 5999688.,
      6031440., 4913760., 4940670., 4926180., 4953180., 4938600., 4965690.,
      4951020., 4978200., 5731005., 5762610., 5745390., 5777100., 5759775.,
      5791590., 5774160., 5806080., 6547440., 6583800., 6563760., 6600240.,
      6580080., 6616680., 6596400., 6633120., 5724495., 5756520., 5738670.,
      5770800., 5752845., 5785080., 5767020., 5799360., 4902600., 4930230.,
      4914660., 4942380., 4926720., 4954530., 4938780., 4966680., 3880896.,
      3903576., 3890256., 3913008., 3899616., 3922440., 3908976., 3931872.,
      4523652., 4550280., 4534488., 4561200., 4545324., 4572120., 4556160.,
      4583040., 5164992., 5195616., 5177280., 5208000., 5189568., 5220384.,
      5201856., 5232768., 4513068., 4540032., 4523736., 4550784., 4534404.,
      4561536., 4545072., 4572288., 3862752., 3886008., 3871824., 3895152.,
      3880896., 3904296., 3889968., 3913440.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      174768., 179928., 175344., 180528., 175920., 181128., 176496., 181728.,
      177072., 182328., 177648., 182928., 178224., 183528., 178800., 184128.,
      179376., 184728., 179952., 185328., 180528., 185928., 181104., 186528.,
      181680., 187128., 182256., 187728., 182832., 188328., 183408., 188928.,
      183984., 189528., 184560., 190128., 185136., 190728., 185712., 191328.,
      193200., 199128., 193776., 199728., 194352., 200328., 194928., 200928.,
      195504., 201528., 196080., 202128., 196656., 202728., 197232., 203328.,
      197808., 203928., 198384., 204528., 198960., 205128., 199536., 205728.,
      200112., 206328., 200688., 206928., 201264., 207528., 201840., 208128.,
      202416., 208728., 202992., 209328., 203568., 209928., 204144., 210528.,
      211632., 218328., 212208., 218928., 212784., 219528., 213360., 220128.,
      213936., 220728., 214512., 221328., 215088., 221928., 215664., 222528.,
      216240., 223128., 216816., 223728., 217392., 224328., 217968., 224928.,
      218544., 225528., 219120., 226128., 219696., 226728., 220272., 227328.,
      220848., 227928., 221424., 228528., 222000., 229128., 222576., 229728.,
      230064., 237528., 230640., 238128., 231216., 238728., 231792., 239328.,
      232368., 239928., 232944., 240528., 233520., 241128., 234096., 241728.,
      234672., 242328., 235248., 242928., 235824., 243528., 236400., 244128.,
      236976., 244728., 237552., 245328., 238128., 245928., 238704., 246528.,
      239280., 247128., 239856., 247728., 240432., 248328., 241008., 248928.,
      248496., 256728., 249072., 257328., 249648., 257928., 250224., 258528.,
      250800., 259128., 251376., 259728., 251952., 260328., 252528., 260928.,
      253104., 261528., 253680., 262128., 254256., 262728., 254832., 263328.,
      255408., 263928., 255984., 264528., 256560., 265128., 257136., 265728.,
      257712., 266328., 258288., 266928., 258864., 267528., 259440., 268128.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7702248.,  7720320.,  7738392.,  7756464.,  7725504.,  7743648.,
      7761792.,  7779936.,  7748760.,  7766976.,  7785192.,  7803408.,
      7772016.,  7790304.,  7808592.,  7826880.,  8999172.,  9020424.,
      9041676.,  9062928.,  9026136.,  9047472.,  9068808.,  9090144.,
      9053100.,  9074520.,  9095940.,  9117360.,  9080064.,  9101568.,
      9123072.,  9144576.,  10299360., 10323840., 10348320., 10372800.,
      10329984., 10354560., 10379136., 10403712., 10360608., 10385280.,
      10409952., 10434624., 10391232., 10416000., 10440768., 10465536.,
      9020676.,  9042264.,  9063852.,  9085440.,  9047304.,  9068976.,
      9090648.,  9112320.,  9073932.,  9095688.,  9117444.,  9139200.,
      9100560.,  9122400.,  9144240.,  9166080.,  7739112.,  7757760.,
      7776408.,  7795056.,  7761792.,  7780512.,  7799232.,  7817952.,
      7784472.,  7803264.,  7822056.,  7840848.,  7807152.,  7826016.,
      7844880.,  7863744.,  9777570.,  9801600.,  9825630.,  9849660.,
      9805200.,  9829320.,  9853440.,  9877560.,  9832830.,  9857040.,
      9881250.,  9905460.,  9860460.,  9884760.,  9909060.,  9933360.,
      11416965., 11445210., 11473455., 11501700., 11448990., 11477340.,
      11505690., 11534040., 11481015., 11509470., 11537925., 11566380.,
      11513040., 11541600., 11570160., 11598720., 13058520., 13091040.,
      13123560., 13156080., 13094880., 13127520., 13160160., 13192800.,
      13131240., 13164000., 13196760., 13229520., 13167600., 13200480.,
      13233360., 13266240., 11430405., 11459070., 11487735., 11516400.,
      11462010., 11490780., 11519550., 11548320., 11493615., 11522490.,
      11551365., 11580240., 11525220., 11554200., 11583180., 11612160.,
      9800610.,  9825360.,  9850110.,  9874860.,  9827520.,  9852360.,
      9877200.,  9902040.,  9854430.,  9879360.,  9904290.,  9929220.,
      9881340.,  9906360.,  9931380.,  9956400.,  11875932., 11906496.,
      11937060., 11967624., 11907360., 11938032., 11968704., 11999376.,
      11938788., 11969568., 12000348., 12031128., 11970216., 12001104.,
      12031992., 12062880., 13858950., 13894860., 13930770., 13966680.,
      13895364., 13931400., 13967436., 14003472., 13931778., 13967940.,
      14004102., 14040264., 13968192., 14004480., 14040768., 14077056.,
      15842256., 15883584., 15924912., 15966240., 15883584., 15925056.,
      15966528., 16008000., 15924912., 15966528., 16008144., 16049760.,
      15966240., 16008000., 16049760., 16091520., 13858950., 13895364.,
      13931778., 13968192., 13894860., 13931400., 13967940., 14004480.,
      13930770., 13967436., 14004102., 14040768., 13966680., 14003472.,
      14040264., 14077056., 11875932., 11907360., 11938788., 11970216.,
      11906496., 11938032., 11969568., 12001104., 11937060., 11968704.,
      12000348., 12031992., 11967624., 11999376., 12031128., 12062880.,
      9800610.,  9827520.,  9854430.,  9881340.,  9825360.,  9852360.,
      9879360.,  9906360.,  9850110.,  9877200.,  9904290.,  9931380.,
      9874860.,  9902040.,  9929220.,  9956400.,  11430405., 11462010.,
      11493615., 11525220., 11459070., 11490780., 11522490., 11554200.,
      11487735., 11519550., 11551365., 11583180., 11516400., 11548320.,
      11580240., 11612160., 13058520., 13094880., 13131240., 13167600.,
      13091040., 13127520., 13164000., 13200480., 13123560., 13160160.,
      13196760., 13233360., 13156080., 13192800., 13229520., 13266240.,
      11416965., 11448990., 11481015., 11513040., 11445210., 11477340.,
      11509470., 11541600., 11473455., 11505690., 11537925., 11570160.,
      11501700., 11534040., 11566380., 11598720., 9777570.,  9805200.,
      9832830.,  9860460.,  9801600.,  9829320.,  9857040.,  9884760.,
      9825630.,  9853440.,  9881250.,  9909060.,  9849660.,  9877560.,
      9905460.,  9933360.,  7739112.,  7761792.,  7784472.,  7807152.,
      7757760.,  7780512.,  7803264.,  7826016.,  7776408.,  7799232.,
      7822056.,  7844880.,  7795056.,  7817952.,  7840848.,  7863744.,
      9020676.,  9047304.,  9073932.,  9100560.,  9042264.,  9068976.,
      9095688.,  9122400.,  9063852.,  9090648.,  9117444.,  9144240.,
      9085440.,  9112320.,  9139200.,  9166080.,  10299360., 10329984.,
      10360608., 10391232., 10323840., 10354560., 10385280., 10416000.,
      10348320., 10379136., 10409952., 10440768., 10372800., 10403712.,
      10434624., 10465536., 8999172.,  9026136.,  9053100.,  9080064.,
      9020424.,  9047472.,  9074520.,  9101568.,  9041676.,  9068808.,
      9095940.,  9123072.,  9062928.,  9090144.,  9117360.,  9144576.,
      7702248.,  7725504.,  7748760.,  7772016.,  7720320.,  7743648.,
      7766976.,  7790304.,  7738392.,  7761792.,  7785192.,  7808592.,
      7756464.,  7779936.,  7803408.,  7826880.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x6x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      344376., 349536., 354696., 359856., 345504., 350688., 355872., 361056.,
      346632., 351840., 357048., 362256., 347760., 352992., 358224., 363456.,
      348888., 354144., 359400., 364656., 350016., 355296., 360576., 365856.,
      351144., 356448., 361752., 367056., 352272., 357600., 362928., 368256.,
      353400., 358752., 364104., 369456., 354528., 359904., 365280., 370656.,
      355656., 361056., 366456., 371856., 356784., 362208., 367632., 373056.,
      357912., 363360., 368808., 374256., 359040., 364512., 369984., 375456.,
      360168., 365664., 371160., 376656., 361296., 366816., 372336., 377856.,
      362424., 367968., 373512., 379056., 363552., 369120., 374688., 380256.,
      364680., 370272., 375864., 381456., 365808., 371424., 377040., 382656.,
      380472., 386400., 392328., 398256., 381600., 387552., 393504., 399456.,
      382728., 388704., 394680., 400656., 383856., 389856., 395856., 401856.,
      384984., 391008., 397032., 403056., 386112., 392160., 398208., 404256.,
      387240., 393312., 399384., 405456., 388368., 394464., 400560., 406656.,
      389496., 395616., 401736., 407856., 390624., 396768., 402912., 409056.,
      391752., 397920., 404088., 410256., 392880., 399072., 405264., 411456.,
      394008., 400224., 406440., 412656., 395136., 401376., 407616., 413856.,
      396264., 402528., 408792., 415056., 397392., 403680., 409968., 416256.,
      398520., 404832., 411144., 417456., 399648., 405984., 412320., 418656.,
      400776., 407136., 413496., 419856., 401904., 408288., 414672., 421056.,
      416568., 423264., 429960., 436656., 417696., 424416., 431136., 437856.,
      418824., 425568., 432312., 439056., 419952., 426720., 433488., 440256.,
      421080., 427872., 434664., 441456., 422208., 429024., 435840., 442656.,
      423336., 430176., 437016., 443856., 424464., 431328., 438192., 445056.,
      425592., 432480., 439368., 446256., 426720., 433632., 440544., 447456.,
      427848., 434784., 441720., 448656., 428976., 435936., 442896., 449856.,
      430104., 437088., 444072., 451056., 431232., 438240., 445248., 452256.,
      432360., 439392., 446424., 453456., 433488., 440544., 447600., 454656.,
      434616., 441696., 448776., 455856., 435744., 442848., 449952., 457056.,
      436872., 444000., 451128., 458256., 438000., 445152., 452304., 459456.,
      452664., 460128., 467592., 475056., 453792., 461280., 468768., 476256.,
      454920., 462432., 469944., 477456., 456048., 463584., 471120., 478656.,
      457176., 464736., 472296., 479856., 458304., 465888., 473472., 481056.,
      459432., 467040., 474648., 482256., 460560., 468192., 475824., 483456.,
      461688., 469344., 477000., 484656., 462816., 470496., 478176., 485856.,
      463944., 471648., 479352., 487056., 465072., 472800., 480528., 488256.,
      466200., 473952., 481704., 489456., 467328., 475104., 482880., 490656.,
      468456., 476256., 484056., 491856., 469584., 477408., 485232., 493056.,
      470712., 478560., 486408., 494256., 471840., 479712., 487584., 495456.,
      472968., 480864., 488760., 496656., 474096., 482016., 489936., 497856.,
      488760., 496992., 505224., 513456., 489888., 498144., 506400., 514656.,
      491016., 499296., 507576., 515856., 492144., 500448., 508752., 517056.,
      493272., 501600., 509928., 518256., 494400., 502752., 511104., 519456.,
      495528., 503904., 512280., 520656., 496656., 505056., 513456., 521856.,
      497784., 506208., 514632., 523056., 498912., 507360., 515808., 524256.,
      500040., 508512., 516984., 525456., 501168., 509664., 518160., 526656.,
      502296., 510816., 519336., 527856., 503424., 511968., 520512., 529056.,
      504552., 513120., 521688., 530256., 505680., 514272., 522864., 531456.,
      506808., 515424., 524040., 532656., 507936., 516576., 525216., 533856.,
      509064., 517728., 526392., 535056., 510192., 518880., 527568., 536256.};
  const std::array<int, 4> in_shape = {{3, 6, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      313950., 393000., 472245., 393900., 315390., 381492., 477270.,
      573174., 477810., 382356., 449610., 562170., 674751., 562170.,
      449610., 382356., 477810., 573174., 477270., 381492., 315390.,
      393900., 472245., 393000., 313950.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11637., 11808., 11979., 12150., 12321., 12663., 12834., 13005., 13176.,
      13347., 13689., 13860., 14031., 14202., 14373., 14715., 14886., 15057.,
      15228., 15399., 15741., 15912., 16083., 16254., 16425.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      624510.,  627900.,  781725.,  786000.,  939315.,  944490.,  783450.,
      787800.,  627270.,  630780.,  758700.,  762984.,  949140.,  954540.,
      1139814., 1146348., 950130.,  955620.,  760284.,  764712.,  893970.,
      899220.,  1117725., 1124340., 1341501., 1349502., 1117620., 1124340.,
      893802.,  899220.,  759996.,  764712.,  949680.,  955620.,  1139166.,
      1146348., 948510.,  954540.,  758124.,  762984.,  626670.,  630780.,
      782625.,  787800.,  938235.,  944490.,  780750.,  786000.,  623670.,
      627900.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      22383., 23274., 22707., 23616., 23031., 23958., 23355., 24300., 23679.,
      24642., 24327., 25326., 24651., 25668., 24975., 26010., 25299., 26352.,
      25623., 26694., 26271., 27378., 26595., 27720., 26919., 28062., 27243.,
      28404., 27567., 28746., 28215., 29430., 28539., 29772., 28863., 30114.,
      29187., 30456., 29511., 30798., 30159., 31482., 30483., 31824., 30807.,
      32166., 31131., 32508., 31455., 32850.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1245630., 1249020., 1252410., 1255800., 1559175., 1563450., 1567725.,
      1572000., 1873455., 1878630., 1883805., 1888980., 1562550., 1566900.,
      1571250., 1575600., 1251030., 1254540., 1258050., 1261560., 1513116.,
      1517400., 1521684., 1525968., 1892880., 1898280., 1903680., 1909080.,
      2273094., 2279628., 2286162., 2292696., 1894770., 1900260., 1905750.,
      1911240., 1516140., 1520568., 1524996., 1529424., 1782690., 1787940.,
      1793190., 1798440., 2228835., 2235450., 2242065., 2248680., 2675001.,
      2683002., 2691003., 2699004., 2228520., 2235240., 2241960., 2248680.,
      1782186., 1787604., 1793022., 1798440., 1515276., 1519992., 1524708.,
      1529424., 1893420., 1899360., 1905300., 1911240., 2271150., 2278332.,
      2285514., 2292696., 1890990., 1897020., 1903050., 1909080., 1511388.,
      1516248., 1521108., 1525968., 1249230., 1253340., 1257450., 1261560.,
      1560075., 1565250., 1570425., 1575600., 1870215., 1876470., 1882725.,
      1888980., 1556250., 1561500., 1566750., 1572000., 1243110., 1247340.,
      1251570., 1255800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43875., 44766., 45657., 46548., 44505., 45414., 46323., 47232., 45135.,
      46062., 46989., 47916., 45765., 46710., 47655., 48600., 46395., 47358.,
      48321., 49284., 47655., 48654., 49653., 50652., 48285., 49302., 50319.,
      51336., 48915., 49950., 50985., 52020., 49545., 50598., 51651., 52704.,
      50175., 51246., 52317., 53388., 51435., 52542., 53649., 54756., 52065.,
      53190., 54315., 55440., 52695., 53838., 54981., 56124., 53325., 54486.,
      55647., 56808., 53955., 55134., 56313., 57492., 55215., 56430., 57645.,
      58860., 55845., 57078., 58311., 59544., 56475., 57726., 58977., 60228.,
      57105., 58374., 59643., 60912., 57735., 59022., 60309., 61596., 58995.,
      60318., 61641., 62964., 59625., 60966., 62307., 63648., 60255., 61614.,
      62973., 64332., 60885., 62262., 63639., 65016., 61515., 62910., 64305.,
      65700.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      623670.,  627900.,  780750.,  786000.,  938235.,  944490.,  782625.,
      787800.,  626670.,  630780.,  758124.,  762984.,  948510.,  954540.,
      1139166., 1146348., 949680.,  955620.,  759996.,  764712.,  893802.,
      899220.,  1117620., 1124340., 1341501., 1349502., 1117725., 1124340.,
      893970.,  899220.,  760284.,  764712.,  950130.,  955620.,  1139814.,
      1146348., 949140.,  954540.,  758700.,  762984.,  627270.,  630780.,
      783450.,  787800.,  939315.,  944490.,  781725.,  786000.,  624510.,
      627900.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      23103., 23274., 23445., 23616., 23787., 23958., 24129., 24300., 24471.,
      24642., 25155., 25326., 25497., 25668., 25839., 26010., 26181., 26352.,
      26523., 26694., 27207., 27378., 27549., 27720., 27891., 28062., 28233.,
      28404., 28575., 28746., 29259., 29430., 29601., 29772., 29943., 30114.,
      30285., 30456., 30627., 30798., 31311., 31482., 31653., 31824., 31995.,
      32166., 32337., 32508., 32679., 32850.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1240620., 1247340., 1249020., 1255800., 1553025., 1561500., 1563450.,
      1572000., 1866210., 1876470., 1878630., 1888980., 1556625., 1565250.,
      1566900., 1575600., 1246380., 1253340., 1254540., 1261560., 1507752.,
      1516248., 1517400., 1525968., 1886310., 1897020., 1898280., 1909080.,
      2265372., 2278332., 2279628., 2292696., 1888470., 1899360., 1900260.,
      1911240., 1511208., 1519992., 1520568., 1529424., 1777188., 1787604.,
      1787940., 1798440., 2222115., 2235240., 2235450., 2248680., 2667126.,
      2683002., 2683002., 2699004., 2222115., 2235450., 2235240., 2248680.,
      1777188., 1787940., 1787604., 1798440., 1511208., 1520568., 1519992.,
      1529424., 1888470., 1900260., 1899360., 1911240., 2265372., 2279628.,
      2278332., 2292696., 1886310., 1898280., 1897020., 1909080., 1507752.,
      1517400., 1516248., 1525968., 1246380., 1254540., 1253340., 1261560.,
      1556625., 1566900., 1565250., 1575600., 1866210., 1878630., 1876470.,
      1888980., 1553025., 1563450., 1561500., 1572000., 1240620., 1249020.,
      1247340., 1255800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      44442., 46206., 44766., 46548., 45090., 46890., 45414., 47232., 45738.,
      47574., 46062., 47916., 46386., 48258., 46710., 48600., 47034., 48942.,
      47358., 49284., 48330., 50310., 48654., 50652., 48978., 50994., 49302.,
      51336., 49626., 51678., 49950., 52020., 50274., 52362., 50598., 52704.,
      50922., 53046., 51246., 53388., 52218., 54414., 52542., 54756., 52866.,
      55098., 53190., 55440., 53514., 55782., 53838., 56124., 54162., 56466.,
      54486., 56808., 54810., 57150., 55134., 57492., 56106., 58518., 56430.,
      58860., 56754., 59202., 57078., 59544., 57402., 59886., 57726., 60228.,
      58050., 60570., 58374., 60912., 58698., 61254., 59022., 61596., 59994.,
      62622., 60318., 62964., 60642., 63306., 60966., 63648., 61290., 63990.,
      61614., 64332., 61938., 64674., 62262., 65016., 62586., 65358., 62910.,
      65700.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2474520., 2481240., 2487960., 2494680., 2491260., 2498040., 2504820.,
      2511600., 3097575., 3106050., 3114525., 3123000., 3118350., 3126900.,
      3135450., 3144000., 3722160., 3732420., 3742680., 3752940., 3746910.,
      3757260., 3767610., 3777960., 3104625., 3113250., 3121875., 3130500.,
      3125100., 3133800., 3142500., 3151200., 2485800., 2492760., 2499720.,
      2506680., 2502060., 2509080., 2516100., 2523120., 3007008., 3015504.,
      3024000., 3032496., 3026232., 3034800., 3043368., 3051936., 3761910.,
      3772620., 3783330., 3794040., 3785760., 3796560., 3807360., 3818160.,
      4517784., 4530744., 4543704., 4556664., 4546188., 4559256., 4572324.,
      4585392., 3766050., 3776940., 3787830., 3798720., 3789540., 3800520.,
      3811500., 3822480., 3013632., 3022416., 3031200., 3039984., 3032280.,
      3041136., 3049992., 3058848., 3543960., 3554376., 3564792., 3575208.,
      3565380., 3575880., 3586380., 3596880., 4431105., 4444230., 4457355.,
      4470480., 4457670., 4470900., 4484130., 4497360., 5318376., 5334252.,
      5350128., 5366004., 5350002., 5366004., 5382006., 5398008., 4430895.,
      4444230., 4457565., 4470900., 4457040., 4470480., 4483920., 4497360.,
      3543624., 3554376., 3565128., 3575880., 3564372., 3575208., 3586044.,
      3596880., 3013056., 3022416., 3031776., 3041136., 3030552., 3039984.,
      3049416., 3058848., 3765150., 3776940., 3788730., 3800520., 3786840.,
      3798720., 3810600., 3822480., 4516488., 4530744., 4545000., 4559256.,
      4542300., 4556664., 4571028., 4585392., 3760650., 3772620., 3784590.,
      3796560., 3781980., 3794040., 3806100., 3818160., 3005856., 3015504.,
      3025152., 3034800., 3022776., 3032496., 3042216., 3051936., 2484600.,
      2492760., 2500920., 2509080., 2498460., 2506680., 2514900., 2523120.,
      3102975., 3113250., 3123525., 3133800., 3120150., 3130500., 3140850.,
      3151200., 3720000., 3732420., 3744840., 3757260., 3740430., 3752940.,
      3765450., 3777960., 3095625., 3106050., 3116475., 3126900., 3112500.,
      3123000., 3133500., 3144000., 2472840., 2481240., 2489640., 2498040.,
      2486220., 2494680., 2503140., 2511600.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      87120.,  88884.,  90648.,  92412.,  87750.,  89532.,  91314.,  93096.,
      88380.,  90180.,  91980.,  93780.,  89010.,  90828.,  92646.,  94464.,
      89640.,  91476.,  93312.,  95148.,  90270.,  92124.,  93978.,  95832.,
      90900.,  92772.,  94644.,  96516.,  91530.,  93420.,  95310.,  97200.,
      92160.,  94068.,  95976.,  97884.,  92790.,  94716.,  96642.,  98568.,
      94680.,  96660.,  98640.,  100620., 95310.,  97308.,  99306.,  101304.,
      95940.,  97956.,  99972.,  101988., 96570.,  98604.,  100638., 102672.,
      97200.,  99252.,  101304., 103356., 97830.,  99900.,  101970., 104040.,
      98460.,  100548., 102636., 104724., 99090.,  101196., 103302., 105408.,
      99720.,  101844., 103968., 106092., 100350., 102492., 104634., 106776.,
      102240., 104436., 106632., 108828., 102870., 105084., 107298., 109512.,
      103500., 105732., 107964., 110196., 104130., 106380., 108630., 110880.,
      104760., 107028., 109296., 111564., 105390., 107676., 109962., 112248.,
      106020., 108324., 110628., 112932., 106650., 108972., 111294., 113616.,
      107280., 109620., 111960., 114300., 107910., 110268., 112626., 114984.,
      109800., 112212., 114624., 117036., 110430., 112860., 115290., 117720.,
      111060., 113508., 115956., 118404., 111690., 114156., 116622., 119088.,
      112320., 114804., 117288., 119772., 112950., 115452., 117954., 120456.,
      113580., 116100., 118620., 121140., 114210., 116748., 119286., 121824.,
      114840., 117396., 119952., 122508., 115470., 118044., 120618., 123192.,
      117360., 119988., 122616., 125244., 117990., 120636., 123282., 125928.,
      118620., 121284., 123948., 126612., 119250., 121932., 124614., 127296.,
      119880., 122580., 125280., 127980., 120510., 123228., 125946., 128664.,
      121140., 123876., 126612., 129348., 121770., 124524., 127278., 130032.,
      122400., 125172., 127944., 130716., 123030., 125820., 128610., 131400.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1243110., 1247340., 1251570., 1255800., 1556250., 1561500., 1566750.,
      1572000., 1870215., 1876470., 1882725., 1888980., 1560075., 1565250.,
      1570425., 1575600., 1249230., 1253340., 1257450., 1261560., 1511388.,
      1516248., 1521108., 1525968., 1890990., 1897020., 1903050., 1909080.,
      2271150., 2278332., 2285514., 2292696., 1893420., 1899360., 1905300.,
      1911240., 1515276., 1519992., 1524708., 1529424., 1782186., 1787604.,
      1793022., 1798440., 2228520., 2235240., 2241960., 2248680., 2675001.,
      2683002., 2691003., 2699004., 2228835., 2235450., 2242065., 2248680.,
      1782690., 1787940., 1793190., 1798440., 1516140., 1520568., 1524996.,
      1529424., 1894770., 1900260., 1905750., 1911240., 2273094., 2279628.,
      2286162., 2292696., 1892880., 1898280., 1903680., 1909080., 1513116.,
      1517400., 1521684., 1525968., 1251030., 1254540., 1258050., 1261560.,
      1562550., 1566900., 1571250., 1575600., 1873455., 1878630., 1883805.,
      1888980., 1559175., 1563450., 1567725., 1572000., 1245630., 1249020.,
      1252410., 1255800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46035., 46206., 46377., 46548., 46719., 46890., 47061., 47232., 47403.,
      47574., 47745., 47916., 48087., 48258., 48429., 48600., 48771., 48942.,
      49113., 49284., 50139., 50310., 50481., 50652., 50823., 50994., 51165.,
      51336., 51507., 51678., 51849., 52020., 52191., 52362., 52533., 52704.,
      52875., 53046., 53217., 53388., 54243., 54414., 54585., 54756., 54927.,
      55098., 55269., 55440., 55611., 55782., 55953., 56124., 56295., 56466.,
      56637., 56808., 56979., 57150., 57321., 57492., 58347., 58518., 58689.,
      58860., 59031., 59202., 59373., 59544., 59715., 59886., 60057., 60228.,
      60399., 60570., 60741., 60912., 61083., 61254., 61425., 61596., 62451.,
      62622., 62793., 62964., 63135., 63306., 63477., 63648., 63819., 63990.,
      64161., 64332., 64503., 64674., 64845., 65016., 65187., 65358., 65529.,
      65700.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472840., 2486220., 2481240., 2494680., 2489640., 2503140., 2498040.,
      2511600., 3095625., 3112500., 3106050., 3123000., 3116475., 3133500.,
      3126900., 3144000., 3720000., 3740430., 3732420., 3752940., 3744840.,
      3765450., 3757260., 3777960., 3102975., 3120150., 3113250., 3130500.,
      3123525., 3140850., 3133800., 3151200., 2484600., 2498460., 2492760.,
      2506680., 2500920., 2514900., 2509080., 2523120., 3005856., 3022776.,
      3015504., 3032496., 3025152., 3042216., 3034800., 3051936., 3760650.,
      3781980., 3772620., 3794040., 3784590., 3806100., 3796560., 3818160.,
      4516488., 4542300., 4530744., 4556664., 4545000., 4571028., 4559256.,
      4585392., 3765150., 3786840., 3776940., 3798720., 3788730., 3810600.,
      3800520., 3822480., 3013056., 3030552., 3022416., 3039984., 3031776.,
      3049416., 3041136., 3058848., 3543624., 3564372., 3554376., 3575208.,
      3565128., 3586044., 3575880., 3596880., 4430895., 4457040., 4444230.,
      4470480., 4457565., 4483920., 4470900., 4497360., 5318376., 5350002.,
      5334252., 5366004., 5350128., 5382006., 5366004., 5398008., 4431105.,
      4457670., 4444230., 4470900., 4457355., 4484130., 4470480., 4497360.,
      3543960., 3565380., 3554376., 3575880., 3564792., 3586380., 3575208.,
      3596880., 3013632., 3032280., 3022416., 3041136., 3031200., 3049992.,
      3039984., 3058848., 3766050., 3789540., 3776940., 3800520., 3787830.,
      3811500., 3798720., 3822480., 4517784., 4546188., 4530744., 4559256.,
      4543704., 4572324., 4556664., 4585392., 3761910., 3785760., 3772620.,
      3796560., 3783330., 3807360., 3794040., 3818160., 3007008., 3026232.,
      3015504., 3034800., 3024000., 3043368., 3032496., 3051936., 2485800.,
      2502060., 2492760., 2509080., 2499720., 2516100., 2506680., 2523120.,
      3104625., 3125100., 3113250., 3133800., 3121875., 3142500., 3130500.,
      3151200., 3722160., 3746910., 3732420., 3757260., 3742680., 3767610.,
      3752940., 3777960., 3097575., 3118350., 3106050., 3126900., 3114525.,
      3135450., 3123000., 3144000., 2474520., 2491260., 2481240., 2498040.,
      2487960., 2504820., 2494680., 2511600.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      88560.,  92070.,  88884.,  92412.,  89208.,  92754.,  89532.,  93096.,
      89856.,  93438.,  90180.,  93780.,  90504.,  94122.,  90828.,  94464.,
      91152.,  94806.,  91476.,  95148.,  91800.,  95490.,  92124.,  95832.,
      92448.,  96174.,  92772.,  96516.,  93096.,  96858.,  93420.,  97200.,
      93744.,  97542.,  94068.,  97884.,  94392.,  98226.,  94716.,  98568.,
      96336.,  100278., 96660.,  100620., 96984.,  100962., 97308.,  101304.,
      97632.,  101646., 97956.,  101988., 98280.,  102330., 98604.,  102672.,
      98928.,  103014., 99252.,  103356., 99576.,  103698., 99900.,  104040.,
      100224., 104382., 100548., 104724., 100872., 105066., 101196., 105408.,
      101520., 105750., 101844., 106092., 102168., 106434., 102492., 106776.,
      104112., 108486., 104436., 108828., 104760., 109170., 105084., 109512.,
      105408., 109854., 105732., 110196., 106056., 110538., 106380., 110880.,
      106704., 111222., 107028., 111564., 107352., 111906., 107676., 112248.,
      108000., 112590., 108324., 112932., 108648., 113274., 108972., 113616.,
      109296., 113958., 109620., 114300., 109944., 114642., 110268., 114984.,
      111888., 116694., 112212., 117036., 112536., 117378., 112860., 117720.,
      113184., 118062., 113508., 118404., 113832., 118746., 114156., 119088.,
      114480., 119430., 114804., 119772., 115128., 120114., 115452., 120456.,
      115776., 120798., 116100., 121140., 116424., 121482., 116748., 121824.,
      117072., 122166., 117396., 122508., 117720., 122850., 118044., 123192.,
      119664., 124902., 119988., 125244., 120312., 125586., 120636., 125928.,
      120960., 126270., 121284., 126612., 121608., 126954., 121932., 127296.,
      122256., 127638., 122580., 127980., 122904., 128322., 123228., 128664.,
      123552., 129006., 123876., 129348., 124200., 129690., 124524., 130032.,
      124848., 130374., 125172., 130716., 125496., 131058., 125820., 131400.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4932300.,  4945680.,  4959060.,  4972440.,  4949040.,  4962480.,
      4975920.,  4989360.,  4965780.,  4979280.,  4992780.,  5006280.,
      4982520.,  4996080.,  5009640.,  5023200.,  6174375.,  6191250.,
      6208125.,  6225000.,  6195150.,  6212100.,  6229050.,  6246000.,
      6215925.,  6232950.,  6249975.,  6267000.,  6236700.,  6253800.,
      6270900.,  6288000.,  7419570.,  7440000.,  7460430.,  7480860.,
      7444320.,  7464840.,  7485360.,  7505880.,  7469070.,  7489680.,
      7510290.,  7530900.,  7493820.,  7514520.,  7535220.,  7555920.,
      6188775.,  6205950.,  6223125.,  6240300.,  6209250.,  6226500.,
      6243750.,  6261000.,  6229725.,  6247050.,  6264375.,  6281700.,
      6250200.,  6267600.,  6285000.,  6302400.,  4955340.,  4969200.,
      4983060.,  4996920.,  4971600.,  4985520.,  4999440.,  5013360.,
      4987860.,  5001840.,  5015820.,  5029800.,  5004120.,  5018160.,
      5032200.,  5046240.,  5994792.,  6011712.,  6028632.,  6045552.,
      6014016.,  6031008.,  6048000.,  6064992.,  6033240.,  6050304.,
      6067368.,  6084432.,  6052464.,  6069600.,  6086736.,  6103872.,
      7499970.,  7521300.,  7542630.,  7563960.,  7523820.,  7545240.,
      7566660.,  7588080.,  7547670.,  7569180.,  7590690.,  7612200.,
      7571520.,  7593120.,  7614720.,  7636320.,  9007164.,  9032976.,
      9058788.,  9084600.,  9035568.,  9061488.,  9087408.,  9113328.,
      9063972.,  9090000.,  9116028.,  9142056.,  9092376.,  9118512.,
      9144648.,  9170784.,  7508610.,  7530300.,  7551990.,  7573680.,
      7532100.,  7553880.,  7575660.,  7597440.,  7555590.,  7577460.,
      7599330.,  7621200.,  7579080.,  7601040.,  7623000.,  7644960.,
      6008616.,  6026112.,  6043608.,  6061104.,  6027264.,  6044832.,
      6062400.,  6079968.,  6045912.,  6063552.,  6081192.,  6098832.,
      6064560.,  6082272.,  6099984.,  6117696.,  7066500.,  7087248.,
      7107996.,  7128744.,  7087920.,  7108752.,  7129584.,  7150416.,
      7109340.,  7130256.,  7151172.,  7172088.,  7130760.,  7151760.,
      7172760.,  7193760.,  8835645.,  8861790.,  8887935.,  8914080.,
      8862210.,  8888460.,  8914710.,  8940960.,  8888775.,  8915130.,
      8941485.,  8967840.,  8915340.,  8941800.,  8968260.,  8994720.,
      10605126., 10636752., 10668378., 10700004., 10636752., 10668504.,
      10700256., 10732008., 10668378., 10700256., 10732134., 10764012.,
      10700004., 10732008., 10764012., 10796016., 8835645.,  8862210.,
      8888775.,  8915340.,  8861790.,  8888460.,  8915130.,  8941800.,
      8887935.,  8914710.,  8941485.,  8968260.,  8914080.,  8940960.,
      8967840.,  8994720.,  7066500.,  7087920.,  7109340.,  7130760.,
      7087248.,  7108752.,  7130256.,  7151760.,  7107996.,  7129584.,
      7151172.,  7172760.,  7128744.,  7150416.,  7172088.,  7193760.,
      6008616.,  6027264.,  6045912.,  6064560.,  6026112.,  6044832.,
      6063552.,  6082272.,  6043608.,  6062400.,  6081192.,  6099984.,
      6061104.,  6079968.,  6098832.,  6117696.,  7508610.,  7532100.,
      7555590.,  7579080.,  7530300.,  7553880.,  7577460.,  7601040.,
      7551990.,  7575660.,  7599330.,  7623000.,  7573680.,  7597440.,
      7621200.,  7644960.,  9007164.,  9035568.,  9063972.,  9092376.,
      9032976.,  9061488.,  9090000.,  9118512.,  9058788.,  9087408.,
      9116028.,  9144648.,  9084600.,  9113328.,  9142056.,  9170784.,
      7499970.,  7523820.,  7547670.,  7571520.,  7521300.,  7545240.,
      7569180.,  7593120.,  7542630.,  7566660.,  7590690.,  7614720.,
      7563960.,  7588080.,  7612200.,  7636320.,  5994792.,  6014016.,
      6033240.,  6052464.,  6011712.,  6031008.,  6050304.,  6069600.,
      6028632.,  6048000.,  6067368.,  6086736.,  6045552.,  6064992.,
      6084432.,  6103872.,  4955340.,  4971600.,  4987860.,  5004120.,
      4969200.,  4985520.,  5001840.,  5018160.,  4983060.,  4999440.,
      5015820.,  5032200.,  4996920.,  5013360.,  5029800.,  5046240.,
      6188775.,  6209250.,  6229725.,  6250200.,  6205950.,  6226500.,
      6247050.,  6267600.,  6223125.,  6243750.,  6264375.,  6285000.,
      6240300.,  6261000.,  6281700.,  6302400.,  7419570.,  7444320.,
      7469070.,  7493820.,  7440000.,  7464840.,  7489680.,  7514520.,
      7460430.,  7485360.,  7510290.,  7535220.,  7480860.,  7505880.,
      7530900.,  7555920.,  6174375.,  6195150.,  6215925.,  6236700.,
      6191250.,  6212100.,  6232950.,  6253800.,  6208125.,  6229050.,
      6249975.,  6270900.,  6225000.,  6246000.,  6267000.,  6288000.,
      4932300.,  4949040.,  4965780.,  4982520.,  4945680.,  4962480.,
      4979280.,  4996080.,  4959060.,  4975920.,  4992780.,  5009640.,
      4972440.,  4989360.,  5006280.,  5023200.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      173610., 177120., 180630., 184140., 174240., 177768., 181296., 184824.,
      174870., 178416., 181962., 185508., 175500., 179064., 182628., 186192.,
      176130., 179712., 183294., 186876., 176760., 180360., 183960., 187560.,
      177390., 181008., 184626., 188244., 178020., 181656., 185292., 188928.,
      178650., 182304., 185958., 189612., 179280., 182952., 186624., 190296.,
      179910., 183600., 187290., 190980., 180540., 184248., 187956., 191664.,
      181170., 184896., 188622., 192348., 181800., 185544., 189288., 193032.,
      182430., 186192., 189954., 193716., 183060., 186840., 190620., 194400.,
      183690., 187488., 191286., 195084., 184320., 188136., 191952., 195768.,
      184950., 188784., 192618., 196452., 185580., 189432., 193284., 197136.,
      188730., 192672., 196614., 200556., 189360., 193320., 197280., 201240.,
      189990., 193968., 197946., 201924., 190620., 194616., 198612., 202608.,
      191250., 195264., 199278., 203292., 191880., 195912., 199944., 203976.,
      192510., 196560., 200610., 204660., 193140., 197208., 201276., 205344.,
      193770., 197856., 201942., 206028., 194400., 198504., 202608., 206712.,
      195030., 199152., 203274., 207396., 195660., 199800., 203940., 208080.,
      196290., 200448., 204606., 208764., 196920., 201096., 205272., 209448.,
      197550., 201744., 205938., 210132., 198180., 202392., 206604., 210816.,
      198810., 203040., 207270., 211500., 199440., 203688., 207936., 212184.,
      200070., 204336., 208602., 212868., 200700., 204984., 209268., 213552.,
      203850., 208224., 212598., 216972., 204480., 208872., 213264., 217656.,
      205110., 209520., 213930., 218340., 205740., 210168., 214596., 219024.,
      206370., 210816., 215262., 219708., 207000., 211464., 215928., 220392.,
      207630., 212112., 216594., 221076., 208260., 212760., 217260., 221760.,
      208890., 213408., 217926., 222444., 209520., 214056., 218592., 223128.,
      210150., 214704., 219258., 223812., 210780., 215352., 219924., 224496.,
      211410., 216000., 220590., 225180., 212040., 216648., 221256., 225864.,
      212670., 217296., 221922., 226548., 213300., 217944., 222588., 227232.,
      213930., 218592., 223254., 227916., 214560., 219240., 223920., 228600.,
      215190., 219888., 224586., 229284., 215820., 220536., 225252., 229968.,
      218970., 223776., 228582., 233388., 219600., 224424., 229248., 234072.,
      220230., 225072., 229914., 234756., 220860., 225720., 230580., 235440.,
      221490., 226368., 231246., 236124., 222120., 227016., 231912., 236808.,
      222750., 227664., 232578., 237492., 223380., 228312., 233244., 238176.,
      224010., 228960., 233910., 238860., 224640., 229608., 234576., 239544.,
      225270., 230256., 235242., 240228., 225900., 230904., 235908., 240912.,
      226530., 231552., 236574., 241596., 227160., 232200., 237240., 242280.,
      227790., 232848., 237906., 242964., 228420., 233496., 238572., 243648.,
      229050., 234144., 239238., 244332., 229680., 234792., 239904., 245016.,
      230310., 235440., 240570., 245700., 230940., 236088., 241236., 246384.,
      234090., 239328., 244566., 249804., 234720., 239976., 245232., 250488.,
      235350., 240624., 245898., 251172., 235980., 241272., 246564., 251856.,
      236610., 241920., 247230., 252540., 237240., 242568., 247896., 253224.,
      237870., 243216., 248562., 253908., 238500., 243864., 249228., 254592.,
      239130., 244512., 249894., 255276., 239760., 245160., 250560., 255960.,
      240390., 245808., 251226., 256644., 241020., 246456., 251892., 257328.,
      241650., 247104., 252558., 258012., 242280., 247752., 253224., 258696.,
      242910., 248400., 253890., 259380., 243540., 249048., 254556., 260064.,
      244170., 249696., 255222., 260748., 244800., 250344., 255888., 261432.,
      245430., 250992., 256554., 262116., 246060., 251640., 257220., 262800.};
  const std::array<int, 4> in_shape = {{3, 7, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      533450., 640920., 748615., 642180., 535550., 648120.,  778302.,
      908628., 779058., 649380., 763735., 916692., 1069670., 916692.,
      763735., 649380., 779058., 908628., 778302., 648120.,  535550.,
      642180., 748615., 640920., 533450.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30258., 30636., 31014., 31392., 31770., 32904., 33282., 33660., 34038.,
      34416., 35550., 35928., 36306., 36684., 37062., 38196., 38574., 38952.,
      39330., 39708., 40842., 41220., 41598., 41976., 42354.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1061950., 1066900., 1275855., 1281840., 1490195., 1497230., 1278285.,
      1284360., 1066000., 1071100., 1289985., 1296240., 1549044., 1556604.,
      1808373., 1817256., 1550448., 1558116., 1292325., 1298760., 1519805.,
      1527470., 1824123., 1833384., 2128462., 2139340., 1823997., 1833384.,
      1519595., 1527470., 1291875., 1298760., 1549800., 1558116., 1807491.,
      1817256., 1548180., 1556604., 1289175., 1296240., 1065100., 1071100.,
      1277115., 1284360., 1488725., 1497230., 1274505., 1281840., 1060750.,
      1066900.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      58950., 60516., 59679., 61272., 60408., 62028., 61137., 62784., 61866.,
      63540., 64053., 65808., 64782., 66564., 65511., 67320., 66240., 68076.,
      66969., 68832., 69156., 71100., 69885., 71856., 70614., 72612., 71343.,
      73368., 72072., 74124., 74259., 76392., 74988., 77148., 75717., 77904.,
      76446., 78660., 77175., 79416., 79362., 81684., 80091., 82440., 80820.,
      83196., 81549., 83952., 82278., 84708.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2118950., 2123900., 2128850., 2133800., 2545725., 2551710., 2557695.,
      2563680., 2973355., 2980390., 2987425., 2994460., 2550495., 2556570.,
      2562645., 2568720., 2126900., 2132000., 2137100., 2142200., 2573715.,
      2579970., 2586225., 2592480., 3090528., 3098088., 3105648., 3113208.,
      3607863., 3616746., 3625629., 3634512., 3093228., 3100896., 3108564.,
      3116232., 2578215., 2584650., 2591085., 2597520., 3031945., 3039610.,
      3047275., 3054940., 3638985., 3648246., 3657507., 3666768., 4246046.,
      4256924., 4267802., 4278680., 3638607., 3647994., 3657381., 3666768.,
      3031315., 3039190., 3047065., 3054940., 2576865., 2583750., 2590635.,
      2597520., 3091284., 3099600., 3107916., 3116232., 3605217., 3614982.,
      3624747., 3634512., 3087936., 3096360., 3104784., 3113208., 2571285.,
      2578350., 2585415., 2592480., 2124200., 2130200., 2136200., 2142200.,
      2546985., 2554230., 2561475., 2568720., 2968945., 2977450., 2985955.,
      2994460., 2541675., 2549010., 2556345., 2563680., 2115350., 2121500.,
      2127650., 2133800.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      116334., 117900., 119466., 121032., 117765., 119358., 120951., 122544.,
      119196., 120816., 122436., 124056., 120627., 122274., 123921., 125568.,
      122058., 123732., 125406., 127080., 126351., 128106., 129861., 131616.,
      127782., 129564., 131346., 133128., 129213., 131022., 132831., 134640.,
      130644., 132480., 134316., 136152., 132075., 133938., 135801., 137664.,
      136368., 138312., 140256., 142200., 137799., 139770., 141741., 143712.,
      139230., 141228., 143226., 145224., 140661., 142686., 144711., 146736.,
      142092., 144144., 146196., 148248., 146385., 148518., 150651., 152784.,
      147816., 149976., 152136., 154296., 149247., 151434., 153621., 155808.,
      150678., 152892., 155106., 157320., 152109., 154350., 156591., 158832.,
      156402., 158724., 161046., 163368., 157833., 160182., 162531., 164880.,
      159264., 161640., 164016., 166392., 160695., 163098., 165501., 167904.,
      162126., 164556., 166986., 169416.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1060750., 1066900., 1274505., 1281840., 1488725., 1497230., 1277115.,
      1284360., 1065100., 1071100., 1289175., 1296240., 1548180., 1556604.,
      1807491., 1817256., 1549800., 1558116., 1291875., 1298760., 1519595.,
      1527470., 1823997., 1833384., 2128462., 2139340., 1824123., 1833384.,
      1519805., 1527470., 1292325., 1298760., 1550448., 1558116., 1808373.,
      1817256., 1549044., 1556604., 1289985., 1296240., 1066000., 1071100.,
      1278285., 1284360., 1490195., 1497230., 1275855., 1281840., 1061950.,
      1066900.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60138., 60516., 60894., 61272., 61650., 62028., 62406., 62784., 63162.,
      63540., 65430., 65808., 66186., 66564., 66942., 67320., 67698., 68076.,
      68454., 68832., 70722., 71100., 71478., 71856., 72234., 72612., 72990.,
      73368., 73746., 74124., 76014., 76392., 76770., 77148., 77526., 77904.,
      78282., 78660., 79038., 79416., 81306., 81684., 82062., 82440., 82818.,
      83196., 83574., 83952., 84330., 84708.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2111675., 2121500., 2123900., 2133800., 2537130., 2549010., 2551710.,
      2563680., 2963485., 2977450., 2980390., 2994460., 2542170., 2554230.,
      2556570., 2568720., 2120075., 2130200., 2132000., 2142200., 2565930.,
      2578350., 2579970., 2592480., 3081348., 3096360., 3098088., 3113208.,
      3597342., 3614982., 3616746., 3634512., 3084372., 3099600., 3100896.,
      3116232., 2570970., 2583750., 2584650., 2597520., 3023965., 3039190.,
      3039610., 3054940., 3629598., 3647994., 3648246., 3666768., 4235315.,
      4256924., 4256924., 4278680., 3629598., 3648246., 3647994., 3666768.,
      3023965., 3039610., 3039190., 3054940., 2570970., 2584650., 2583750.,
      2597520., 3084372., 3100896., 3099600., 3116232., 3597342., 3616746.,
      3614982., 3634512., 3081348., 3098088., 3096360., 3113208., 2565930.,
      2579970., 2578350., 2592480., 2120075., 2132000., 2130200., 2142200.,
      2542170., 2556570., 2554230., 2568720., 2963485., 2980390., 2977450.,
      2994460., 2537130., 2551710., 2549010., 2563680., 2111675., 2123900.,
      2121500., 2133800.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      117171., 120276., 117900., 121032., 118629., 121788., 119358., 122544.,
      120087., 123300., 120816., 124056., 121545., 124812., 122274., 125568.,
      123003., 126324., 123732., 127080., 127377., 130860., 128106., 131616.,
      128835., 132372., 129564., 133128., 130293., 133884., 131022., 134640.,
      131751., 135396., 132480., 136152., 133209., 136908., 133938., 137664.,
      137583., 141444., 138312., 142200., 139041., 142956., 139770., 143712.,
      140499., 144468., 141228., 145224., 141957., 145980., 142686., 146736.,
      143415., 147492., 144144., 148248., 147789., 152028., 148518., 152784.,
      149247., 153540., 149976., 154296., 150705., 155052., 151434., 155808.,
      152163., 156564., 152892., 157320., 153621., 158076., 154350., 158832.,
      157995., 162612., 158724., 163368., 159453., 164124., 160182., 164880.,
      160911., 165636., 161640., 166392., 162369., 167148., 163098., 167904.,
      163827., 168660., 164556., 169416.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4213525., 4223350., 4233175., 4243000., 4237900., 4247800., 4257700.,
      4267600., 5062380., 5074260., 5086140., 5098020., 5091450., 5103420.,
      5115390., 5127360., 5913005., 5926970., 5940935., 5954900., 5946710.,
      5960780., 5974850., 5988920., 5072280., 5084340., 5096400., 5108460.,
      5100990., 5113140., 5125290., 5137440., 4230025., 4240150., 4250275.,
      4260400., 4253800., 4264000., 4274200., 4284400., 5119440., 5131860.,
      5144280., 5156700., 5147430., 5159940., 5172450., 5184960., 6147684.,
      6162696., 6177708., 6192720., 6181056., 6196176., 6211296., 6226416.,
      7177044., 7194684., 7212324., 7229964., 7215726., 7233492., 7251258.,
      7269024., 6153516., 6168744., 6183972., 6199200., 6186456., 6201792.,
      6217128., 6232464., 5129160., 5141940., 5154720., 5167500., 5156430.,
      5169300., 5182170., 5195040., 6032705., 6047930., 6063155., 6078380.,
      6063890., 6079220., 6094550., 6109880., 7240800., 7259196., 7277592.,
      7295988., 7277970., 7296492., 7315014., 7333536., 8449021., 8470630.,
      8492239., 8513848., 8492092., 8513848., 8535604., 8557360., 7240548.,
      7259196., 7277844., 7296492., 7277214., 7295988., 7314762., 7333536.,
      6032285., 6047930., 6063575., 6079220., 6062630., 6078380., 6094130.,
      6109880., 5128260., 5141940., 5155620., 5169300., 5153730., 5167500.,
      5181270., 5195040., 6152220., 6168744., 6185268., 6201792., 6182568.,
      6199200., 6215832., 6232464., 7175280., 7194684., 7214088., 7233492.,
      7210434., 7229964., 7249494., 7269024., 6145956., 6162696., 6179436.,
      6196176., 6175872., 6192720., 6209568., 6226416., 5117820., 5131860.,
      5145900., 5159940., 5142570., 5156700., 5170830., 5184960., 4228225.,
      4240150., 4252075., 4264000., 4248400., 4260400., 4272400., 4284400.,
      5069940., 5084340., 5098740., 5113140., 5093970., 5108460., 5122950.,
      5137440., 5910065., 5926970., 5943875., 5960780., 5937890., 5954900.,
      5971910., 5988920., 5059680., 5074260., 5088840., 5103420., 5083350.,
      5098020., 5112690., 5127360., 4211125., 4223350., 4235575., 4247800.,
      4230700., 4243000., 4255300., 4267600.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      231237., 234342., 237447., 240552., 232668., 235800., 238932., 242064.,
      234099., 237258., 240417., 243576., 235530., 238716., 241902., 245088.,
      236961., 240174., 243387., 246600., 238392., 241632., 244872., 248112.,
      239823., 243090., 246357., 249624., 241254., 244548., 247842., 251136.,
      242685., 246006., 249327., 252648., 244116., 247464., 250812., 254160.,
      251271., 254754., 258237., 261720., 252702., 256212., 259722., 263232.,
      254133., 257670., 261207., 264744., 255564., 259128., 262692., 266256.,
      256995., 260586., 264177., 267768., 258426., 262044., 265662., 269280.,
      259857., 263502., 267147., 270792., 261288., 264960., 268632., 272304.,
      262719., 266418., 270117., 273816., 264150., 267876., 271602., 275328.,
      271305., 275166., 279027., 282888., 272736., 276624., 280512., 284400.,
      274167., 278082., 281997., 285912., 275598., 279540., 283482., 287424.,
      277029., 280998., 284967., 288936., 278460., 282456., 286452., 290448.,
      279891., 283914., 287937., 291960., 281322., 285372., 289422., 293472.,
      282753., 286830., 290907., 294984., 284184., 288288., 292392., 296496.,
      291339., 295578., 299817., 304056., 292770., 297036., 301302., 305568.,
      294201., 298494., 302787., 307080., 295632., 299952., 304272., 308592.,
      297063., 301410., 305757., 310104., 298494., 302868., 307242., 311616.,
      299925., 304326., 308727., 313128., 301356., 305784., 310212., 314640.,
      302787., 307242., 311697., 316152., 304218., 308700., 313182., 317664.,
      311373., 315990., 320607., 325224., 312804., 317448., 322092., 326736.,
      314235., 318906., 323577., 328248., 315666., 320364., 325062., 329760.,
      317097., 321822., 326547., 331272., 318528., 323280., 328032., 332784.,
      319959., 324738., 329517., 334296., 321390., 326196., 331002., 335808.,
      322821., 327654., 332487., 337320., 324252., 329112., 333972., 338832.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2115350., 2121500., 2127650., 2133800., 2541675., 2549010., 2556345.,
      2563680., 2968945., 2977450., 2985955., 2994460., 2546985., 2554230.,
      2561475., 2568720., 2124200., 2130200., 2136200., 2142200., 2571285.,
      2578350., 2585415., 2592480., 3087936., 3096360., 3104784., 3113208.,
      3605217., 3614982., 3624747., 3634512., 3091284., 3099600., 3107916.,
      3116232., 2576865., 2583750., 2590635., 2597520., 3031315., 3039190.,
      3047065., 3054940., 3638607., 3647994., 3657381., 3666768., 4246046.,
      4256924., 4267802., 4278680., 3638985., 3648246., 3657507., 3666768.,
      3031945., 3039610., 3047275., 3054940., 2578215., 2584650., 2591085.,
      2597520., 3093228., 3100896., 3108564., 3116232., 3607863., 3616746.,
      3625629., 3634512., 3090528., 3098088., 3105648., 3113208., 2573715.,
      2579970., 2586225., 2592480., 2126900., 2132000., 2137100., 2142200.,
      2550495., 2556570., 2562645., 2568720., 2973355., 2980390., 2987425.,
      2994460., 2545725., 2551710., 2557695., 2563680., 2118950., 2123900.,
      2128850., 2133800.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119898., 120276., 120654., 121032., 121410., 121788., 122166., 122544.,
      122922., 123300., 123678., 124056., 124434., 124812., 125190., 125568.,
      125946., 126324., 126702., 127080., 130482., 130860., 131238., 131616.,
      131994., 132372., 132750., 133128., 133506., 133884., 134262., 134640.,
      135018., 135396., 135774., 136152., 136530., 136908., 137286., 137664.,
      141066., 141444., 141822., 142200., 142578., 142956., 143334., 143712.,
      144090., 144468., 144846., 145224., 145602., 145980., 146358., 146736.,
      147114., 147492., 147870., 148248., 151650., 152028., 152406., 152784.,
      153162., 153540., 153918., 154296., 154674., 155052., 155430., 155808.,
      156186., 156564., 156942., 157320., 157698., 158076., 158454., 158832.,
      162234., 162612., 162990., 163368., 163746., 164124., 164502., 164880.,
      165258., 165636., 166014., 166392., 166770., 167148., 167526., 167904.,
      168282., 168660., 169038., 169416.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4211125., 4230700., 4223350., 4243000., 4235575., 4255300., 4247800.,
      4267600., 5059680., 5083350., 5074260., 5098020., 5088840., 5112690.,
      5103420., 5127360., 5910065., 5937890., 5926970., 5954900., 5943875.,
      5971910., 5960780., 5988920., 5069940., 5093970., 5084340., 5108460.,
      5098740., 5122950., 5113140., 5137440., 4228225., 4248400., 4240150.,
      4260400., 4252075., 4272400., 4264000., 4284400., 5117820., 5142570.,
      5131860., 5156700., 5145900., 5170830., 5159940., 5184960., 6145956.,
      6175872., 6162696., 6192720., 6179436., 6209568., 6196176., 6226416.,
      7175280., 7210434., 7194684., 7229964., 7214088., 7249494., 7233492.,
      7269024., 6152220., 6182568., 6168744., 6199200., 6185268., 6215832.,
      6201792., 6232464., 5128260., 5153730., 5141940., 5167500., 5155620.,
      5181270., 5169300., 5195040., 6032285., 6062630., 6047930., 6078380.,
      6063575., 6094130., 6079220., 6109880., 7240548., 7277214., 7259196.,
      7295988., 7277844., 7314762., 7296492., 7333536., 8449021., 8492092.,
      8470630., 8513848., 8492239., 8535604., 8513848., 8557360., 7240800.,
      7277970., 7259196., 7296492., 7277592., 7315014., 7295988., 7333536.,
      6032705., 6063890., 6047930., 6079220., 6063155., 6094550., 6078380.,
      6109880., 5129160., 5156430., 5141940., 5169300., 5154720., 5182170.,
      5167500., 5195040., 6153516., 6186456., 6168744., 6201792., 6183972.,
      6217128., 6199200., 6232464., 7177044., 7215726., 7194684., 7233492.,
      7212324., 7251258., 7229964., 7269024., 6147684., 6181056., 6162696.,
      6196176., 6177708., 6211296., 6192720., 6226416., 5119440., 5147430.,
      5131860., 5159940., 5144280., 5172450., 5156700., 5184960., 4230025.,
      4253800., 4240150., 4264000., 4250275., 4274200., 4260400., 4284400.,
      5072280., 5100990., 5084340., 5113140., 5096400., 5125290., 5108460.,
      5137440., 5913005., 5946710., 5926970., 5960780., 5940935., 5974850.,
      5954900., 5988920., 5062380., 5091450., 5074260., 5103420., 5086140.,
      5115390., 5098020., 5127360., 4213525., 4237900., 4223350., 4247800.,
      4233175., 4257700., 4243000., 4267600.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      233613., 239796., 234342., 240552., 235071., 241308., 235800., 242064.,
      236529., 242820., 237258., 243576., 237987., 244332., 238716., 245088.,
      239445., 245844., 240174., 246600., 240903., 247356., 241632., 248112.,
      242361., 248868., 243090., 249624., 243819., 250380., 244548., 251136.,
      245277., 251892., 246006., 252648., 246735., 253404., 247464., 254160.,
      254025., 260964., 254754., 261720., 255483., 262476., 256212., 263232.,
      256941., 263988., 257670., 264744., 258399., 265500., 259128., 266256.,
      259857., 267012., 260586., 267768., 261315., 268524., 262044., 269280.,
      262773., 270036., 263502., 270792., 264231., 271548., 264960., 272304.,
      265689., 273060., 266418., 273816., 267147., 274572., 267876., 275328.,
      274437., 282132., 275166., 282888., 275895., 283644., 276624., 284400.,
      277353., 285156., 278082., 285912., 278811., 286668., 279540., 287424.,
      280269., 288180., 280998., 288936., 281727., 289692., 282456., 290448.,
      283185., 291204., 283914., 291960., 284643., 292716., 285372., 293472.,
      286101., 294228., 286830., 294984., 287559., 295740., 288288., 296496.,
      294849., 303300., 295578., 304056., 296307., 304812., 297036., 305568.,
      297765., 306324., 298494., 307080., 299223., 307836., 299952., 308592.,
      300681., 309348., 301410., 310104., 302139., 310860., 302868., 311616.,
      303597., 312372., 304326., 313128., 305055., 313884., 305784., 314640.,
      306513., 315396., 307242., 316152., 307971., 316908., 308700., 317664.,
      315261., 324468., 315990., 325224., 316719., 325980., 317448., 326736.,
      318177., 327492., 318906., 328248., 319635., 329004., 320364., 329760.,
      321093., 330516., 321822., 331272., 322551., 332028., 323280., 332784.,
      324009., 333540., 324738., 334296., 325467., 335052., 326196., 335808.,
      326925., 336564., 327654., 337320., 328383., 338076., 329112., 338832.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4571891.,  4589930.,  4607969.,  4626008.,  4588586.,  4606700.,
      4624814.,  4642928.,  4605281.,  4623470.,  4641659.,  4659848.,
      4621976.,  4640240.,  4658504.,  4676768.,  5700170.,  5721792.,
      5743414.,  5765036.,  5720536.,  5742248.,  5763960.,  5785672.,
      5740902.,  5762704.,  5784506.,  5806308.,  5761268.,  5783160.,
      5805052.,  5826944.,  6830001.,  6855266.,  6880531.,  6905796.,
      6853978.,  6879348.,  6904718.,  6930088.,  6877955.,  6903430.,
      6928905.,  6954380.,  6901932.,  6927512.,  6953092.,  6978672.,
      5900554.,  5922024.,  5943494.,  5964964.,  5921072.,  5942632.,
      5964192.,  5985752.,  5941590.,  5963240.,  5984890.,  6006540.,
      5962108.,  5983848.,  6005588.,  6027328.,  4974131.,  4991746.,
      5009361.,  5026976.,  4991250.,  5008940.,  5026630.,  5044320.,
      5008369.,  5026134.,  5043899.,  5061664.,  5025488.,  5043328.,
      5061168.,  5079008.,  6041674.,  6062328.,  6082982.,  6103636.,
      6061984.,  6082728.,  6103472.,  6124216.,  6082294.,  6103128.,
      6123962.,  6144796.,  6102604.,  6123528.,  6144452.,  6165376.,
      7486572.,  7511368.,  7536164.,  7560960.,  7511240.,  7536144.,
      7561048.,  7585952.,  7535908.,  7560920.,  7585932.,  7610944.,
      7560576.,  7585696.,  7610816.,  7635936.,  8933774.,  8962784.,
      8991794.,  9020804.,  8962728.,  8991864.,  9021000.,  9050136.,
      8991682.,  9020944.,  9050206.,  9079468.,  9020636.,  9050024.,
      9079412.,  9108800.,  7719852.,  7744568.,  7769284.,  7794000.,
      7744600.,  7769424.,  7794248.,  7819072.,  7769348.,  7794280.,
      7819212.,  7844144.,  7794096.,  7819136.,  7844176.,  7869216.,
      6508298.,  6528648.,  6548998.,  6569348.,  6528912.,  6549352.,
      6569792.,  6590232.,  6549526.,  6570056.,  6590586.,  6611116.,
      6570140.,  6590760.,  6611380.,  6632000.,  7598257.,  7621946.,
      7645635.,  7669324.,  7621762.,  7645556.,  7669350.,  7693144.,
      7645267.,  7669166.,  7693065.,  7716964.,  7668772.,  7692776.,
      7716780.,  7740784.,  9375118.,  9403592.,  9432066.,  9460540.,
      9403584.,  9432184.,  9460784.,  9489384.,  9432050.,  9460776.,
      9489502.,  9518228.,  9460516.,  9489368.,  9518220.,  9547072.,
      11154363., 11187706., 11221049., 11254392., 11187706., 11221196.,
      11254686., 11288176., 11221049., 11254686., 11288323., 11321960.,
      11254392., 11288176., 11321960., 11355744., 9375118.,  9403584.,
      9432050.,  9460516.,  9403592.,  9432184.,  9460776.,  9489368.,
      9432066.,  9460784.,  9489502.,  9518220.,  9460540.,  9489384.,
      9518228.,  9547072.,  7598257.,  7621762.,  7645267.,  7668772.,
      7621946.,  7645556.,  7669166.,  7692776.,  7645635.,  7669350.,
      7693065.,  7716780.,  7669324.,  7693144.,  7716964.,  7740784.,
      6508298.,  6528912.,  6549526.,  6570140.,  6528648.,  6549352.,
      6570056.,  6590760.,  6548998.,  6569792.,  6590586.,  6611380.,
      6569348.,  6590232.,  6611116.,  6632000.,  7719852.,  7744600.,
      7769348.,  7794096.,  7744568.,  7769424.,  7794280.,  7819136.,
      7769284.,  7794248.,  7819212.,  7844176.,  7794000.,  7819072.,
      7844144.,  7869216.,  8933774.,  8962728.,  8991682.,  9020636.,
      8962784.,  8991864.,  9020944.,  9050024.,  8991794.,  9021000.,
      9050206.,  9079412.,  9020804.,  9050136.,  9079468.,  9108800.,
      7486572.,  7511240.,  7535908.,  7560576.,  7511368.,  7536144.,
      7560920.,  7585696.,  7536164.,  7561048.,  7585932.,  7610816.,
      7560960.,  7585952.,  7610944.,  7635936.,  6041674.,  6061984.,
      6082294.,  6102604.,  6062328.,  6082728.,  6103128.,  6123528.,
      6082982.,  6103472.,  6123962.,  6144452.,  6103636.,  6124216.,
      6144796.,  6165376.,  4974131.,  4991250.,  5008369.,  5025488.,
      4991746.,  5008940.,  5026134.,  5043328.,  5009361.,  5026630.,
      5043899.,  5061168.,  5026976.,  5044320.,  5061664.,  5079008.,
      5900554.,  5921072.,  5941590.,  5962108.,  5922024.,  5942632.,
      5963240.,  5983848.,  5943494.,  5964192.,  5984890.,  6005588.,
      5964964.,  5985752.,  6006540.,  6027328.,  6830001.,  6853978.,
      6877955.,  6901932.,  6855266.,  6879348.,  6903430.,  6927512.,
      6880531.,  6904718.,  6928905.,  6953092.,  6905796.,  6930088.,
      6954380.,  6978672.,  5700170.,  5720536.,  5740902.,  5761268.,
      5721792.,  5742248.,  5762704.,  5783160.,  5743414.,  5763960.,
      5784506.,  5805052.,  5765036.,  5785672.,  5806308.,  5826944.,
      4571891.,  4588586.,  4605281.,  4621976.,  4589930.,  4606700.,
      4623470.,  4640240.,  4607969.,  4624814.,  4641659.,  4658504.,
      4626008.,  4642928.,  4659848.,  4676768.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      461043., 467226., 473409., 479592., 462474., 468684., 474894., 481104.,
      463905., 470142., 476379., 482616., 465336., 471600., 477864., 484128.,
      466767., 473058., 479349., 485640., 468198., 474516., 480834., 487152.,
      469629., 475974., 482319., 488664., 471060., 477432., 483804., 490176.,
      472491., 478890., 485289., 491688., 473922., 480348., 486774., 493200.,
      475353., 481806., 488259., 494712., 476784., 483264., 489744., 496224.,
      478215., 484722., 491229., 497736., 479646., 486180., 492714., 499248.,
      481077., 487638., 494199., 500760., 482508., 489096., 495684., 502272.,
      483939., 490554., 497169., 503784., 485370., 492012., 498654., 505296.,
      486801., 493470., 500139., 506808., 488232., 494928., 501624., 508320.,
      501111., 508050., 514989., 521928., 502542., 509508., 516474., 523440.,
      503973., 510966., 517959., 524952., 505404., 512424., 519444., 526464.,
      506835., 513882., 520929., 527976., 508266., 515340., 522414., 529488.,
      509697., 516798., 523899., 531000., 511128., 518256., 525384., 532512.,
      512559., 519714., 526869., 534024., 513990., 521172., 528354., 535536.,
      515421., 522630., 529839., 537048., 516852., 524088., 531324., 538560.,
      518283., 525546., 532809., 540072., 519714., 527004., 534294., 541584.,
      521145., 528462., 535779., 543096., 522576., 529920., 537264., 544608.,
      524007., 531378., 538749., 546120., 525438., 532836., 540234., 547632.,
      526869., 534294., 541719., 549144., 528300., 535752., 543204., 550656.,
      541179., 548874., 556569., 564264., 542610., 550332., 558054., 565776.,
      544041., 551790., 559539., 567288., 545472., 553248., 561024., 568800.,
      546903., 554706., 562509., 570312., 548334., 556164., 563994., 571824.,
      549765., 557622., 565479., 573336., 551196., 559080., 566964., 574848.,
      552627., 560538., 568449., 576360., 554058., 561996., 569934., 577872.,
      555489., 563454., 571419., 579384., 556920., 564912., 572904., 580896.,
      558351., 566370., 574389., 582408., 559782., 567828., 575874., 583920.,
      561213., 569286., 577359., 585432., 562644., 570744., 578844., 586944.,
      564075., 572202., 580329., 588456., 565506., 573660., 581814., 589968.,
      566937., 575118., 583299., 591480., 568368., 576576., 584784., 592992.,
      581247., 589698., 598149., 606600., 582678., 591156., 599634., 608112.,
      584109., 592614., 601119., 609624., 585540., 594072., 602604., 611136.,
      586971., 595530., 604089., 612648., 588402., 596988., 605574., 614160.,
      589833., 598446., 607059., 615672., 591264., 599904., 608544., 617184.,
      592695., 601362., 610029., 618696., 594126., 602820., 611514., 620208.,
      595557., 604278., 612999., 621720., 596988., 605736., 614484., 623232.,
      598419., 607194., 615969., 624744., 599850., 608652., 617454., 626256.,
      601281., 610110., 618939., 627768., 602712., 611568., 620424., 629280.,
      604143., 613026., 621909., 630792., 605574., 614484., 623394., 632304.,
      607005., 615942., 624879., 633816., 608436., 617400., 626364., 635328.,
      621315., 630522., 639729., 648936., 622746., 631980., 641214., 650448.,
      624177., 633438., 642699., 651960., 625608., 634896., 644184., 653472.,
      627039., 636354., 645669., 654984., 628470., 637812., 647154., 656496.,
      629901., 639270., 648639., 658008., 631332., 640728., 650124., 659520.,
      632763., 642186., 651609., 661032., 634194., 643644., 653094., 662544.,
      635625., 645102., 654579., 664056., 637056., 646560., 656064., 665568.,
      638487., 648018., 657549., 667080., 639918., 649476., 659034., 668592.,
      641349., 650934., 660519., 670104., 642780., 652392., 662004., 671616.,
      644211., 653850., 663489., 673128., 645642., 655308., 664974., 674640.,
      647073., 656766., 666459., 676152., 648504., 658224., 667944., 677664.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      835275.,  975520.,  1116020., 977200.,  838155.,  1014714., 1184568.,
      1354584., 1185576., 1016442., 1195593., 1395128., 1594684., 1395128.,
      1195593., 1016442., 1185576., 1354584., 1184568., 1014714., 838155.,
      977200.,  1116020., 975520.,  835275.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      61230., 61896., 62562., 63228., 63894., 66558., 67224., 67890., 68556.,
      69222., 71886., 72552., 73218., 73884., 74550., 77214., 77880., 78546.,
      79212., 79878., 82542., 83208., 83874., 84540., 85206.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1663755., 1670550., 1943060., 1951040., 2222860., 2232040., 1946315.,
      1954400., 1669335., 1676310., 2020842., 2029428., 2359056., 2369136.,
      2697576., 2709168., 2360946., 2371152., 2024082., 2032884., 2380665.,
      2391186., 2777908., 2790256., 3175172., 3189368., 2777761., 2790256.,
      2380413., 2391186., 2023434., 2032884., 2360064., 2371152., 2696424.,
      2709168., 2357922., 2369136., 2019762., 2029428., 1668075., 1676310.,
      1944740., 1954400., 2220940., 2232040., 1941275., 1951040., 1662135.,
      1670550.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      120066., 122460., 121362., 123792., 122658., 125124., 123954., 126456.,
      125250., 127788., 130434., 133116., 131730., 134448., 133026., 135780.,
      134322., 137112., 135618., 138444., 140802., 143772., 142098., 145104.,
      143394., 146436., 144690., 147768., 145986., 149100., 151170., 154428.,
      152466., 155760., 153762., 157092., 155058., 158424., 156354., 159756.,
      161538., 165084., 162834., 166416., 164130., 167748., 165426., 169080.,
      166722., 170412.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3320715., 3327510., 3334305., 3341100., 3878140., 3886120., 3894100.,
      3902080., 4436540., 4445720., 4454900., 4464080., 3884545., 3892630.,
      3900715., 3908800., 3331695., 3338670., 3345645., 3352620., 4033098.,
      4041684., 4050270., 4058856., 4708032., 4718112., 4728192., 4738272.,
      5383560., 5395152., 5406744., 5418336., 4711686., 4721892., 4732098.,
      4742304., 4039362., 4048164., 4056966., 4065768., 4750809., 4761330.,
      4771851., 4782372., 5543468., 5555816., 5568164., 5580512., 6336148.,
      6350344., 6364540., 6378736., 5543027., 5555522., 5568017., 5580512.,
      4750053., 4760826., 4771599., 4782372., 4037418., 4046868., 4056318.,
      4065768., 4709040., 4720128., 4731216., 4742304., 5380104., 5392848.,
      5405592., 5418336., 4704630., 4715844., 4727058., 4738272., 4029858.,
      4039524., 4049190., 4058856., 3327915., 3336150., 3344385., 3352620.,
      3879820., 3889480., 3899140., 3908800., 4430780., 4441880., 4452980.,
      4464080., 3872785., 3882550., 3892315., 3902080., 3315855., 3324270.,
      3332685., 3341100.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237738., 240132., 242526., 244920., 240294., 242724., 245154., 247584.,
      242850., 245316., 247782., 250248., 245406., 247908., 250410., 252912.,
      247962., 250500., 253038., 255576., 258186., 260868., 263550., 266232.,
      260742., 263460., 266178., 268896., 263298., 266052., 268806., 271560.,
      265854., 268644., 271434., 274224., 268410., 271236., 274062., 276888.,
      278634., 281604., 284574., 287544., 281190., 284196., 287202., 290208.,
      283746., 286788., 289830., 292872., 286302., 289380., 292458., 295536.,
      288858., 291972., 295086., 298200., 299082., 302340., 305598., 308856.,
      301638., 304932., 308226., 311520., 304194., 307524., 310854., 314184.,
      306750., 310116., 313482., 316848., 309306., 312708., 316110., 319512.,
      319530., 323076., 326622., 330168., 322086., 325668., 329250., 332832.,
      324642., 328260., 331878., 335496., 327198., 330852., 334506., 338160.,
      329754., 333444., 337134., 340824.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1662135., 1670550., 1941275., 1951040., 2220940., 2232040., 1944740.,
      1954400., 1668075., 1676310., 2019762., 2029428., 2357922., 2369136.,
      2696424., 2709168., 2360064., 2371152., 2023434., 2032884., 2380413.,
      2391186., 2777761., 2790256., 3175172., 3189368., 2777908., 2790256.,
      2380665., 2391186., 2024082., 2032884., 2360946., 2371152., 2697576.,
      2709168., 2359056., 2369136., 2020842., 2029428., 1669335., 1676310.,
      1946315., 1954400., 2222860., 2232040., 1943060., 1951040., 1663755.,
      1670550.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      121794., 122460., 123126., 123792., 124458., 125124., 125790., 126456.,
      127122., 127788., 132450., 133116., 133782., 134448., 135114., 135780.,
      136446., 137112., 137778., 138444., 143106., 143772., 144438., 145104.,
      145770., 146436., 147102., 147768., 148434., 149100., 153762., 154428.,
      155094., 155760., 156426., 157092., 157758., 158424., 159090., 159756.,
      164418., 165084., 165750., 166416., 167082., 167748., 168414., 169080.,
      169746., 170412.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3310770., 3324270., 3327510., 3341100., 3866695., 3882550., 3886120.,
      3902080., 4423640., 4441880., 4445720., 4464080., 3873415., 3889480.,
      3892630., 3908800., 3322290., 3336150., 3338670., 3352620., 4022460.,
      4039524., 4041684., 4058856., 4695810., 4715844., 4718112., 4738272.,
      5369808., 5392848., 5395152., 5418336., 4699842., 4720128., 4721892.,
      4742304., 4029372., 4046868., 4048164., 4065768., 4739910., 4760826.,
      4761330., 4782372., 5530973., 5555522., 5555816., 5580512., 6322120.,
      6350344., 6350344., 6378736., 5530973., 5555816., 5555522., 5580512.,
      4739910., 4761330., 4760826., 4782372., 4029372., 4048164., 4046868.,
      4065768., 4699842., 4721892., 4720128., 4742304., 5369808., 5395152.,
      5392848., 5418336., 4695810., 4718112., 4715844., 4738272., 4022460.,
      4041684., 4039524., 4058856., 3322290., 3338670., 3336150., 3352620.,
      3873415., 3892630., 3889480., 3908800., 4423640., 4445720., 4441880.,
      4464080., 3866695., 3886120., 3882550., 3902080., 3310770., 3327510.,
      3324270., 3341100.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      238836., 243588., 240132., 244920., 241428., 246252., 242724., 247584.,
      244020., 248916., 245316., 250248., 246612., 251580., 247908., 252912.,
      249204., 254244., 250500., 255576., 259572., 264900., 260868., 266232.,
      262164., 267564., 263460., 268896., 264756., 270228., 266052., 271560.,
      267348., 272892., 268644., 274224., 269940., 275556., 271236., 276888.,
      280308., 286212., 281604., 287544., 282900., 288876., 284196., 290208.,
      285492., 291540., 286788., 292872., 288084., 294204., 289380., 295536.,
      290676., 296868., 291972., 298200., 301044., 307524., 302340., 308856.,
      303636., 310188., 304932., 311520., 306228., 312852., 307524., 314184.,
      308820., 315516., 310116., 316848., 311412., 318180., 312708., 319512.,
      321780., 328836., 323076., 330168., 324372., 331500., 325668., 332832.,
      326964., 334164., 328260., 335496., 329556., 336828., 330852., 338160.,
      332148., 339492., 333444., 340824.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6608040.,  6621540.,  6635040.,  6648540.,  6641430.,  6655020.,
      6668610.,  6682200.,  7717535.,  7733390.,  7749245.,  7765100.,
      7756280.,  7772240.,  7788200.,  7804160.,  8829040.,  8847280.,
      8865520.,  8883760.,  8873080.,  8891440.,  8909800.,  8928160.,
      7730765.,  7746830.,  7762895.,  7778960.,  7769090.,  7785260.,
      7801430.,  7817600.,  6630720.,  6644580.,  6658440.,  6672300.,
      6663390.,  6677340.,  6691290.,  6705240.,  8027856.,  8044920.,
      8061984.,  8079048.,  8066196.,  8083368.,  8100540.,  8117712.,
      9371586.,  9391620.,  9411654.,  9431688.,  9416064.,  9436224.,
      9456384.,  9476544.,  10716576., 10739616., 10762656., 10785696.,
      10767120., 10790304., 10813488., 10836672., 9379398.,  9399684.,
      9419970.,  9440256.,  9423372.,  9443784.,  9464196.,  9484608.,
      8041248.,  8058744.,  8076240.,  8093736.,  8078724.,  8096328.,
      8113932.,  8131536.,  9458904.,  9479820.,  9500736.,  9521652.,
      9501618.,  9522660.,  9543702.,  9564744.,  11037397., 11061946.,
      11086495., 11111044., 11086936., 11111632., 11136328., 11161024.,
      12616016., 12644240., 12672464., 12700688., 12672296., 12700688.,
      12729080., 12757472., 11037103., 11061946., 11086789., 11111632.,
      11086054., 11111044., 11136034., 11161024., 9458400.,  9479820.,
      9501240.,  9522660.,  9500106.,  9521652.,  9543198.,  9564744.,
      8039952.,  8058744.,  8077536.,  8096328.,  8074836.,  8093736.,
      8112636.,  8131536.,  9377634.,  9399684.,  9421734.,  9443784.,
      9418080.,  9440256.,  9462432.,  9484608.,  10714272., 10739616.,
      10764960., 10790304., 10760208., 10785696., 10811184., 10836672.,
      9369318.,  9391620.,  9413922.,  9436224.,  9409260.,  9431688.,
      9454116.,  9476544.,  8025696.,  8044920.,  8064144.,  8083368.,
      8059716.,  8079048.,  8098380.,  8117712.,  6628200.,  6644580.,
      6660960.,  6677340.,  6655830.,  6672300.,  6688770.,  6705240.,
      7727615.,  7746830.,  7766045.,  7785260.,  7759640.,  7778960.,
      7798280.,  7817600.,  8825200.,  8847280.,  8869360.,  8891440.,
      8861560.,  8883760.,  8905960.,  8928160.,  7713965.,  7733390.,
      7752815.,  7772240.,  7745570.,  7765100.,  7784630.,  7804160.,
      6604800.,  6621540.,  6638280.,  6655020.,  6631710.,  6648540.,
      6665370.,  6682200.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      472920., 477672., 482424., 487176., 475476., 480264., 485052., 489840.,
      478032., 482856., 487680., 492504., 480588., 485448., 490308., 495168.,
      483144., 488040., 492936., 497832., 485700., 490632., 495564., 500496.,
      488256., 493224., 498192., 503160., 490812., 495816., 500820., 505824.,
      493368., 498408., 503448., 508488., 495924., 501000., 506076., 511152.,
      513816., 519144., 524472., 529800., 516372., 521736., 527100., 532464.,
      518928., 524328., 529728., 535128., 521484., 526920., 532356., 537792.,
      524040., 529512., 534984., 540456., 526596., 532104., 537612., 543120.,
      529152., 534696., 540240., 545784., 531708., 537288., 542868., 548448.,
      534264., 539880., 545496., 551112., 536820., 542472., 548124., 553776.,
      554712., 560616., 566520., 572424., 557268., 563208., 569148., 575088.,
      559824., 565800., 571776., 577752., 562380., 568392., 574404., 580416.,
      564936., 570984., 577032., 583080., 567492., 573576., 579660., 585744.,
      570048., 576168., 582288., 588408., 572604., 578760., 584916., 591072.,
      575160., 581352., 587544., 593736., 577716., 583944., 590172., 596400.,
      595608., 602088., 608568., 615048., 598164., 604680., 611196., 617712.,
      600720., 607272., 613824., 620376., 603276., 609864., 616452., 623040.,
      605832., 612456., 619080., 625704., 608388., 615048., 621708., 628368.,
      610944., 617640., 624336., 631032., 613500., 620232., 626964., 633696.,
      616056., 622824., 629592., 636360., 618612., 625416., 632220., 639024.,
      636504., 643560., 650616., 657672., 639060., 646152., 653244., 660336.,
      641616., 648744., 655872., 663000., 644172., 651336., 658500., 665664.,
      646728., 653928., 661128., 668328., 649284., 656520., 663756., 670992.,
      651840., 659112., 666384., 673656., 654396., 661704., 669012., 676320.,
      656952., 664296., 671640., 678984., 659508., 666888., 674268., 681648.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3315855., 3324270., 3332685., 3341100., 3872785., 3882550., 3892315.,
      3902080., 4430780., 4441880., 4452980., 4464080., 3879820., 3889480.,
      3899140., 3908800., 3327915., 3336150., 3344385., 3352620., 4029858.,
      4039524., 4049190., 4058856., 4704630., 4715844., 4727058., 4738272.,
      5380104., 5392848., 5405592., 5418336., 4709040., 4720128., 4731216.,
      4742304., 4037418., 4046868., 4056318., 4065768., 4750053., 4760826.,
      4771599., 4782372., 5543027., 5555522., 5568017., 5580512., 6336148.,
      6350344., 6364540., 6378736., 5543468., 5555816., 5568164., 5580512.,
      4750809., 4761330., 4771851., 4782372., 4039362., 4048164., 4056966.,
      4065768., 4711686., 4721892., 4732098., 4742304., 5383560., 5395152.,
      5406744., 5418336., 4708032., 4718112., 4728192., 4738272., 4033098.,
      4041684., 4050270., 4058856., 3331695., 3338670., 3345645., 3352620.,
      3884545., 3892630., 3900715., 3908800., 4436540., 4445720., 4454900.,
      4464080., 3878140., 3886120., 3894100., 3902080., 3320715., 3327510.,
      3334305., 3341100.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      242922., 243588., 244254., 244920., 245586., 246252., 246918., 247584.,
      248250., 248916., 249582., 250248., 250914., 251580., 252246., 252912.,
      253578., 254244., 254910., 255576., 264234., 264900., 265566., 266232.,
      266898., 267564., 268230., 268896., 269562., 270228., 270894., 271560.,
      272226., 272892., 273558., 274224., 274890., 275556., 276222., 276888.,
      285546., 286212., 286878., 287544., 288210., 288876., 289542., 290208.,
      290874., 291540., 292206., 292872., 293538., 294204., 294870., 295536.,
      296202., 296868., 297534., 298200., 306858., 307524., 308190., 308856.,
      309522., 310188., 310854., 311520., 312186., 312852., 313518., 314184.,
      314850., 315516., 316182., 316848., 317514., 318180., 318846., 319512.,
      328170., 328836., 329502., 330168., 330834., 331500., 332166., 332832.,
      333498., 334164., 334830., 335496., 336162., 336828., 337494., 338160.,
      338826., 339492., 340158., 340824.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6604800.,  6631710.,  6621540.,  6648540.,  6638280.,  6665370.,
      6655020.,  6682200.,  7713965.,  7745570.,  7733390.,  7765100.,
      7752815.,  7784630.,  7772240.,  7804160.,  8825200.,  8861560.,
      8847280.,  8883760.,  8869360.,  8905960.,  8891440.,  8928160.,
      7727615.,  7759640.,  7746830.,  7778960.,  7766045.,  7798280.,
      7785260.,  7817600.,  6628200.,  6655830.,  6644580.,  6672300.,
      6660960.,  6688770.,  6677340.,  6705240.,  8025696.,  8059716.,
      8044920.,  8079048.,  8064144.,  8098380.,  8083368.,  8117712.,
      9369318.,  9409260.,  9391620.,  9431688.,  9413922.,  9454116.,
      9436224.,  9476544.,  10714272., 10760208., 10739616., 10785696.,
      10764960., 10811184., 10790304., 10836672., 9377634.,  9418080.,
      9399684.,  9440256.,  9421734.,  9462432.,  9443784.,  9484608.,
      8039952.,  8074836.,  8058744.,  8093736.,  8077536.,  8112636.,
      8096328.,  8131536.,  9458400.,  9500106.,  9479820.,  9521652.,
      9501240.,  9543198.,  9522660.,  9564744.,  11037103., 11086054.,
      11061946., 11111044., 11086789., 11136034., 11111632., 11161024.,
      12616016., 12672296., 12644240., 12700688., 12672464., 12729080.,
      12700688., 12757472., 11037397., 11086936., 11061946., 11111632.,
      11086495., 11136328., 11111044., 11161024., 9458904.,  9501618.,
      9479820.,  9522660.,  9500736.,  9543702.,  9521652.,  9564744.,
      8041248.,  8078724.,  8058744.,  8096328.,  8076240.,  8113932.,
      8093736.,  8131536.,  9379398.,  9423372.,  9399684.,  9443784.,
      9419970.,  9464196.,  9440256.,  9484608.,  10716576., 10767120.,
      10739616., 10790304., 10762656., 10813488., 10785696., 10836672.,
      9371586.,  9416064.,  9391620.,  9436224.,  9411654.,  9456384.,
      9431688.,  9476544.,  8027856.,  8066196.,  8044920.,  8083368.,
      8061984.,  8100540.,  8079048.,  8117712.,  6630720.,  6663390.,
      6644580.,  6677340.,  6658440.,  6691290.,  6672300.,  6705240.,
      7730765.,  7769090.,  7746830.,  7785260.,  7762895.,  7801430.,
      7778960.,  7817600.,  8829040.,  8873080.,  8847280.,  8891440.,
      8865520.,  8909800.,  8883760.,  8928160.,  7717535.,  7756280.,
      7733390.,  7772240.,  7749245.,  7788200.,  7765100.,  7804160.,
      6608040.,  6641430.,  6621540.,  6655020.,  6635040.,  6668610.,
      6648540.,  6682200.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      476376., 485844., 477672., 487176., 478968., 488508., 480264., 489840.,
      481560., 491172., 482856., 492504., 484152., 493836., 485448., 495168.,
      486744., 496500., 488040., 497832., 489336., 499164., 490632., 500496.,
      491928., 501828., 493224., 503160., 494520., 504492., 495816., 505824.,
      497112., 507156., 498408., 508488., 499704., 509820., 501000., 511152.,
      517848., 528468., 519144., 529800., 520440., 531132., 521736., 532464.,
      523032., 533796., 524328., 535128., 525624., 536460., 526920., 537792.,
      528216., 539124., 529512., 540456., 530808., 541788., 532104., 543120.,
      533400., 544452., 534696., 545784., 535992., 547116., 537288., 548448.,
      538584., 549780., 539880., 551112., 541176., 552444., 542472., 553776.,
      559320., 571092., 560616., 572424., 561912., 573756., 563208., 575088.,
      564504., 576420., 565800., 577752., 567096., 579084., 568392., 580416.,
      569688., 581748., 570984., 583080., 572280., 584412., 573576., 585744.,
      574872., 587076., 576168., 588408., 577464., 589740., 578760., 591072.,
      580056., 592404., 581352., 593736., 582648., 595068., 583944., 596400.,
      600792., 613716., 602088., 615048., 603384., 616380., 604680., 617712.,
      605976., 619044., 607272., 620376., 608568., 621708., 609864., 623040.,
      611160., 624372., 612456., 625704., 613752., 627036., 615048., 628368.,
      616344., 629700., 617640., 631032., 618936., 632364., 620232., 633696.,
      621528., 635028., 622824., 636360., 624120., 637692., 625416., 639024.,
      642264., 656340., 643560., 657672., 644856., 659004., 646152., 660336.,
      647448., 661668., 648744., 663000., 650040., 664332., 651336., 665664.,
      652632., 666996., 653928., 668328., 655224., 669660., 656520., 670992.,
      657816., 672324., 659112., 673656., 660408., 674988., 661704., 676320.,
      663000., 677652., 664296., 678984., 665592., 680316., 666888., 681648.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4089570.,  4107264.,  4124958.,  4142652.,  4107600.,  4125384.,
      4143168.,  4160952.,  4125630.,  4143504.,  4161378.,  4179252.,
      4143660.,  4161624.,  4179588.,  4197552.,  4773349.,  4794202.,
      4815055.,  4835908.,  4794174.,  4815132.,  4836090.,  4857048.,
      4814999.,  4836062.,  4857125.,  4878188.,  4835824.,  4856992.,
      4878160.,  4899328.,  5457112.,  5481184.,  5505256.,  5529328.,
      5480672.,  5504864.,  5529056.,  5553248.,  5504232.,  5528544.,
      5552856.,  5577168.,  5527792.,  5552224.,  5576656.,  5601088.,
      4771557.,  4792830.,  4814103.,  4835376.,  4791962.,  4813340.,
      4834718.,  4856096.,  4812367.,  4833850.,  4855333.,  4876816.,
      4832772.,  4854360.,  4875948.,  4897536.,  4086498.,  4104912.,
      4123326.,  4141740.,  4103808.,  4122312.,  4140816.,  4159320.,
      4121118.,  4139712.,  4158306.,  4176900.,  4138428.,  4157112.,
      4175796.,  4194480.,  6276060.,  6297792.,  6319524.,  6341256.,
      6299040.,  6320880.,  6342720.,  6364560.,  6322020.,  6343968.,
      6365916.,  6387864.,  6345000.,  6367056.,  6389112.,  6411168.,
      7326662.,  7352268.,  7377874.,  7403480.,  7353220.,  7378952.,
      7404684.,  7430416.,  7379778.,  7405636.,  7431494.,  7457352.,
      7406336.,  7432320.,  7458304.,  7484288.,  8377808.,  8407360.,
      8436912.,  8466464.,  8407872.,  8437568.,  8467264.,  8496960.,
      8437936.,  8467776.,  8497616.,  8527456.,  8468000.,  8497984.,
      8527968.,  8557952.,  7328454.,  7354564.,  7380674.,  7406784.,
      7354508.,  7380744.,  7406980.,  7433216.,  7380562.,  7406924.,
      7433286.,  7459648.,  7406616.,  7433104.,  7459592.,  7486080.,
      6279132.,  6301728.,  6324324.,  6346920.,  6301248.,  6323952.,
      6346656.,  6369360.,  6323364.,  6346176.,  6368988.,  6391800.,
      6345480.,  6368400.,  6391320.,  6414240.,  8583894.,  8610240.,
      8636586.,  8662932.,  8611248.,  8637720.,  8664192.,  8690664.,
      8638602.,  8665200.,  8691798.,  8718396.,  8665956.,  8692680.,
      8719404.,  8746128.,  10018855., 10049886., 10080917., 10111948.,
      10050474., 10081652., 10112830., 10144008., 10082093., 10113418.,
      10144743., 10176068., 10113712., 10145184., 10176656., 10208128.,
      11454152., 11489952., 11525752., 11561552., 11489952., 11525920.,
      11561888., 11597856., 11525752., 11561888., 11598024., 11634160.,
      11561552., 11597856., 11634160., 11670464., 10018855., 10050474.,
      10082093., 10113712., 10049886., 10081652., 10113418., 10145184.,
      10080917., 10112830., 10144743., 10176656., 10111948., 10144008.,
      10176068., 10208128., 8583894.,  8611248.,  8638602.,  8665956.,
      8610240.,  8637720.,  8665200.,  8692680.,  8636586.,  8664192.,
      8691798.,  8719404.,  8662932.,  8690664.,  8718396.,  8746128.,
      6279132.,  6301248.,  6323364.,  6345480.,  6301728.,  6323952.,
      6346176.,  6368400.,  6324324.,  6346656.,  6368988.,  6391320.,
      6346920.,  6369360.,  6391800.,  6414240.,  7328454.,  7354508.,
      7380562.,  7406616.,  7354564.,  7380744.,  7406924.,  7433104.,
      7380674.,  7406980.,  7433286.,  7459592.,  7406784.,  7433216.,
      7459648.,  7486080.,  8377808.,  8407872.,  8437936.,  8468000.,
      8407360.,  8437568.,  8467776.,  8497984.,  8436912.,  8467264.,
      8497616.,  8527968.,  8466464.,  8496960.,  8527456.,  8557952.,
      7326662.,  7353220.,  7379778.,  7406336.,  7352268.,  7378952.,
      7405636.,  7432320.,  7377874.,  7404684.,  7431494.,  7458304.,
      7403480.,  7430416.,  7457352.,  7484288.,  6276060.,  6299040.,
      6322020.,  6345000.,  6297792.,  6320880.,  6343968.,  6367056.,
      6319524.,  6342720.,  6365916.,  6389112.,  6341256.,  6364560.,
      6387864.,  6411168.,  4086498.,  4103808.,  4121118.,  4138428.,
      4104912.,  4122312.,  4139712.,  4157112.,  4123326.,  4140816.,
      4158306.,  4175796.,  4141740.,  4159320.,  4176900.,  4194480.,
      4771557.,  4791962.,  4812367.,  4832772.,  4792830.,  4813340.,
      4833850.,  4854360.,  4814103.,  4834718.,  4855333.,  4875948.,
      4835376.,  4856096.,  4876816.,  4897536.,  5457112.,  5480672.,
      5504232.,  5527792.,  5481184.,  5504864.,  5528544.,  5552224.,
      5505256.,  5529056.,  5552856.,  5576656.,  5529328.,  5553248.,
      5577168.,  5601088.,  4773349.,  4794174.,  4814999.,  4835824.,
      4794202.,  4815132.,  4836062.,  4856992.,  4815055.,  4836090.,
      4857125.,  4878160.,  4835908.,  4857048.,  4878188.,  4899328.,
      4089570.,  4107600.,  4125630.,  4143660.,  4107264.,  4125384.,
      4143504.,  4161624.,  4124958.,  4143168.,  4161378.,  4179588.,
      4142652.,  4160952.,  4179252.,  4197552.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x7x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      943284.,  952752.,  962220.,  971688.,  945840.,  955344.,  964848.,
      974352.,  948396.,  957936.,  967476.,  977016.,  950952.,  960528.,
      970104.,  979680.,  953508.,  963120.,  972732.,  982344.,  956064.,
      965712.,  975360.,  985008.,  958620.,  968304.,  977988.,  987672.,
      961176.,  970896.,  980616.,  990336.,  963732.,  973488.,  983244.,
      993000.,  966288.,  976080.,  985872.,  995664.,  968844.,  978672.,
      988500.,  998328.,  971400.,  981264.,  991128.,  1000992., 973956.,
      983856.,  993756.,  1003656., 976512.,  986448.,  996384.,  1006320.,
      979068.,  989040.,  999012.,  1008984., 981624.,  991632.,  1001640.,
      1011648., 984180.,  994224.,  1004268., 1014312., 986736.,  996816.,
      1006896., 1016976., 989292.,  999408.,  1009524., 1019640., 991848.,
      1002000., 1012152., 1022304., 1025076., 1035696., 1046316., 1056936.,
      1027632., 1038288., 1048944., 1059600., 1030188., 1040880., 1051572.,
      1062264., 1032744., 1043472., 1054200., 1064928., 1035300., 1046064.,
      1056828., 1067592., 1037856., 1048656., 1059456., 1070256., 1040412.,
      1051248., 1062084., 1072920., 1042968., 1053840., 1064712., 1075584.,
      1045524., 1056432., 1067340., 1078248., 1048080., 1059024., 1069968.,
      1080912., 1050636., 1061616., 1072596., 1083576., 1053192., 1064208.,
      1075224., 1086240., 1055748., 1066800., 1077852., 1088904., 1058304.,
      1069392., 1080480., 1091568., 1060860., 1071984., 1083108., 1094232.,
      1063416., 1074576., 1085736., 1096896., 1065972., 1077168., 1088364.,
      1099560., 1068528., 1079760., 1090992., 1102224., 1071084., 1082352.,
      1093620., 1104888., 1073640., 1084944., 1096248., 1107552., 1106868.,
      1118640., 1130412., 1142184., 1109424., 1121232., 1133040., 1144848.,
      1111980., 1123824., 1135668., 1147512., 1114536., 1126416., 1138296.,
      1150176., 1117092., 1129008., 1140924., 1152840., 1119648., 1131600.,
      1143552., 1155504., 1122204., 1134192., 1146180., 1158168., 1124760.,
      1136784., 1148808., 1160832., 1127316., 1139376., 1151436., 1163496.,
      1129872., 1141968., 1154064., 1166160., 1132428., 1144560., 1156692.,
      1168824., 1134984., 1147152., 1159320., 1171488., 1137540., 1149744.,
      1161948., 1174152., 1140096., 1152336., 1164576., 1176816., 1142652.,
      1154928., 1167204., 1179480., 1145208., 1157520., 1169832., 1182144.,
      1147764., 1160112., 1172460., 1184808., 1150320., 1162704., 1175088.,
      1187472., 1152876., 1165296., 1177716., 1190136., 1155432., 1167888.,
      1180344., 1192800., 1188660., 1201584., 1214508., 1227432., 1191216.,
      1204176., 1217136., 1230096., 1193772., 1206768., 1219764., 1232760.,
      1196328., 1209360., 1222392., 1235424., 1198884., 1211952., 1225020.,
      1238088., 1201440., 1214544., 1227648., 1240752., 1203996., 1217136.,
      1230276., 1243416., 1206552., 1219728., 1232904., 1246080., 1209108.,
      1222320., 1235532., 1248744., 1211664., 1224912., 1238160., 1251408.,
      1214220., 1227504., 1240788., 1254072., 1216776., 1230096., 1243416.,
      1256736., 1219332., 1232688., 1246044., 1259400., 1221888., 1235280.,
      1248672., 1262064., 1224444., 1237872., 1251300., 1264728., 1227000.,
      1240464., 1253928., 1267392., 1229556., 1243056., 1256556., 1270056.,
      1232112., 1245648., 1259184., 1272720., 1234668., 1248240., 1261812.,
      1275384., 1237224., 1250832., 1264440., 1278048., 1270452., 1284528.,
      1298604., 1312680., 1273008., 1287120., 1301232., 1315344., 1275564.,
      1289712., 1303860., 1318008., 1278120., 1292304., 1306488., 1320672.,
      1280676., 1294896., 1309116., 1323336., 1283232., 1297488., 1311744.,
      1326000., 1285788., 1300080., 1314372., 1328664., 1288344., 1302672.,
      1317000., 1331328., 1290900., 1305264., 1319628., 1333992., 1293456.,
      1307856., 1322256., 1336656., 1296012., 1310448., 1324884., 1339320.,
      1298568., 1313040., 1327512., 1341984., 1301124., 1315632., 1330140.,
      1344648., 1303680., 1318224., 1332768., 1347312., 1306236., 1320816.,
      1335396., 1349976., 1308792., 1323408., 1338024., 1352640., 1311348.,
      1326000., 1340652., 1355304., 1313904., 1328592., 1343280., 1357968.,
      1316460., 1331184., 1345908., 1360632., 1319016., 1333776., 1348536.,
      1363296.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      493164., 617130., 741330., 618210., 494892., 581406.,  727230.,
      873201., 727860., 582414., 670224., 837960., 1005720., 837960.,
      670224., 582414., 727860., 873201., 727230., 581406.,  494892.,
      618210., 741330., 617130., 493164.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24060., 24360., 24660., 24960., 25260., 25860., 26160., 26460., 26760.,
      27060., 27660., 27960., 28260., 28560., 28860., 29460., 29760., 30060.,
      30360., 30660., 31260., 31560., 31860., 32160., 32460.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      981612.,  986328.,  1228320., 1234260., 1475478., 1482660., 1230390.,
      1236420., 984924.,  989784.,  1157058., 1162812., 1447215., 1454460.,
      1737645., 1746402., 1448370., 1455720., 1158906., 1164828., 1333584.,
      1340448., 1667280., 1675920., 2001000., 2011440., 1667160., 1675920.,
      1333392., 1340448., 1158570., 1164828., 1447845., 1455720., 1736889.,
      1746402., 1446480., 1454460., 1156386., 1162812., 984204.,  989784.,
      1229400., 1236420., 1474182., 1482660., 1227150., 1234260., 980604.,
      986328.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      46716., 48120., 47292., 48720., 47868., 49320., 48444., 49920., 49020.,
      50520., 50172., 51720., 50748., 52320., 51324., 52920., 51900., 53520.,
      52476., 54120., 53628., 55320., 54204., 55920., 54780., 56520., 55356.,
      57120., 55932., 57720., 57084., 58920., 57660., 59520., 58236., 60120.,
      58812., 60720., 59388., 61320., 60540., 62520., 61116., 63120., 61692.,
      63720., 62268., 64320., 62844., 64920.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1958508., 1963224., 1967940., 1972656., 2450700., 2456640., 2462580.,
      2468520., 2943774., 2950956., 2958138., 2965320., 2454750., 2460780.,
      2466810., 2472840., 1964988., 1969848., 1974708., 1979568., 2308362.,
      2314116., 2319870., 2325624., 2887185., 2894430., 2901675., 2908920.,
      3466533., 3475290., 3484047., 3492804., 2889390., 2896740., 2904090.,
      2911440., 2311890., 2317812., 2323734., 2329656., 2660304., 2667168.,
      2674032., 2680896., 3325920., 3334560., 3343200., 3351840., 3991560.,
      4002000., 4012440., 4022880., 3325560., 3334320., 3343080., 3351840.,
      2659728., 2666784., 2673840., 2680896., 2310882., 2317140., 2323398.,
      2329656., 2887815., 2895690., 2903565., 2911440., 3464265., 3473778.,
      3483291., 3492804., 2884980., 2892960., 2900940., 2908920., 2306346.,
      2312772., 2319198., 2325624., 1962828., 1968408., 1973988., 1979568.,
      2451780., 2458800., 2465820., 2472840., 2939886., 2948364., 2956842.,
      2965320., 2447190., 2454300., 2461410., 2468520., 1955484., 1961208.,
      1966932., 1972656.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92028.,  93432.,  94836.,  96240.,  93156.,  94584.,  96012.,  97440.,
      94284.,  95736.,  97188.,  98640.,  95412.,  96888.,  98364.,  99840.,
      96540.,  98040.,  99540.,  101040., 98796.,  100344., 101892., 103440.,
      99924.,  101496., 103068., 104640., 101052., 102648., 104244., 105840.,
      102180., 103800., 105420., 107040., 103308., 104952., 106596., 108240.,
      105564., 107256., 108948., 110640., 106692., 108408., 110124., 111840.,
      107820., 109560., 111300., 113040., 108948., 110712., 112476., 114240.,
      110076., 111864., 113652., 115440., 112332., 114168., 116004., 117840.,
      113460., 115320., 117180., 119040., 114588., 116472., 118356., 120240.,
      115716., 117624., 119532., 121440., 116844., 118776., 120708., 122640.,
      119100., 121080., 123060., 125040., 120228., 122232., 124236., 126240.,
      121356., 123384., 125412., 127440., 122484., 124536., 126588., 128640.,
      123612., 125688., 127764., 129840.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      980604.,  986328.,  1227150., 1234260., 1474182., 1482660., 1229400.,
      1236420., 984204.,  989784.,  1156386., 1162812., 1446480., 1454460.,
      1736889., 1746402., 1447845., 1455720., 1158570., 1164828., 1333392.,
      1340448., 1667160., 1675920., 2001000., 2011440., 1667280., 1675920.,
      1333584., 1340448., 1158906., 1164828., 1448370., 1455720., 1737645.,
      1746402., 1447215., 1454460., 1157058., 1162812., 984924.,  989784.,
      1230390., 1236420., 1475478., 1482660., 1228320., 1234260., 981612.,
      986328.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47820., 48120., 48420., 48720., 49020., 49320., 49620., 49920., 50220.,
      50520., 51420., 51720., 52020., 52320., 52620., 52920., 53220., 53520.,
      53820., 54120., 55020., 55320., 55620., 55920., 56220., 56520., 56820.,
      57120., 57420., 57720., 58620., 58920., 59220., 59520., 59820., 60120.,
      60420., 60720., 61020., 61320., 62220., 62520., 62820., 63120., 63420.,
      63720., 64020., 64320., 64620., 64920.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1951848., 1961208., 1963224., 1972656., 2442510., 2454300., 2456640.,
      2468520., 2934108., 2948364., 2950956., 2965320., 2446830., 2458800.,
      2460780., 2472840., 1958760., 1968408., 1969848., 1979568., 2301348.,
      2312772., 2314116., 2325624., 2878575., 2892960., 2894430., 2908920.,
      3456390., 3473778., 3475290., 3492804., 2881095., 2895690., 2896740.,
      2911440., 2305380., 2317140., 2317812., 2329656., 2653152., 2666784.,
      2667168., 2680896., 3317160., 3334320., 3334560., 3351840., 3981264.,
      4002000., 4002000., 4022880., 3317160., 3334560., 3334320., 3351840.,
      2653152., 2667168., 2666784., 2680896., 2305380., 2317812., 2317140.,
      2329656., 2881095., 2896740., 2895690., 2911440., 3456390., 3475290.,
      3473778., 3492804., 2878575., 2894430., 2892960., 2908920., 2301348.,
      2314116., 2312772., 2325624., 1958760., 1969848., 1968408., 1979568.,
      2446830., 2460780., 2458800., 2472840., 2934108., 2950956., 2948364.,
      2965320., 2442510., 2456640., 2454300., 2468520., 1951848., 1963224.,
      1961208., 1972656.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      92856.,  95640.,  93432.,  96240.,  94008.,  96840.,  94584.,  97440.,
      95160.,  98040.,  95736.,  98640.,  96312.,  99240.,  96888.,  99840.,
      97464.,  100440., 98040.,  101040., 99768.,  102840., 100344., 103440.,
      100920., 104040., 101496., 104640., 102072., 105240., 102648., 105840.,
      103224., 106440., 103800., 107040., 104376., 107640., 104952., 108240.,
      106680., 110040., 107256., 110640., 107832., 111240., 108408., 111840.,
      108984., 112440., 109560., 113040., 110136., 113640., 110712., 114240.,
      111288., 114840., 111864., 115440., 113592., 117240., 114168., 117840.,
      114744., 118440., 115320., 119040., 115896., 119640., 116472., 120240.,
      117048., 120840., 117624., 121440., 118200., 122040., 118776., 122640.,
      120504., 124440., 121080., 125040., 121656., 125640., 122232., 126240.,
      122808., 126840., 123384., 127440., 123960., 128040., 124536., 128640.,
      125112., 129240., 125688., 129840.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3894336., 3903696., 3913056., 3922416., 3917016., 3926448., 3935880.,
      3945312., 4873230., 4885020., 4896810., 4908600., 4901400., 4913280.,
      4925160., 4937040., 5853960., 5868216., 5882472., 5896728., 5887548.,
      5901912., 5916276., 5930640., 4881690., 4893660., 4905630., 4917600.,
      4909500., 4921560., 4933620., 4945680., 3907872., 3917520., 3927168.,
      3936816., 3929976., 3939696., 3949416., 3959136., 4591272., 4602696.,
      4614120., 4625544., 4616724., 4628232., 4639740., 4651248., 5742765.,
      5757150., 5771535., 5785920., 5774370., 5788860., 5803350., 5817840.,
      6895392., 6912780., 6930168., 6947556., 6933066., 6950580., 6968094.,
      6985608., 5747595., 5762190., 5776785., 5791380., 5778780., 5793480.,
      5808180., 5822880., 4599000., 4610760., 4622520., 4634280., 4623780.,
      4635624., 4647468., 4659312., 5292672., 5306304., 5319936., 5333568.,
      5320608., 5334336., 5348064., 5361792., 6617160., 6634320., 6651480.,
      6668640., 6651840., 6669120., 6686400., 6703680., 7941792., 7962528.,
      7983264., 8004000., 7983120., 8004000., 8024880., 8045760., 6616920.,
      6634320., 6651720., 6669120., 6651120., 6668640., 6686160., 6703680.,
      5292288., 5306304., 5320320., 5334336., 5319456., 5333568., 5347680.,
      5361792., 4598328., 4610760., 4623192., 4635624., 4621764., 4634280.,
      4646796., 4659312., 5746545., 5762190., 5777835., 5793480., 5775630.,
      5791380., 5807130., 5822880., 6893880., 6912780., 6931680., 6950580.,
      6928530., 6947556., 6966582., 6985608., 5741295., 5757150., 5773005.,
      5788860., 5769960., 5785920., 5801880., 5817840., 4589928., 4602696.,
      4615464., 4628232., 4612692., 4625544., 4638396., 4651248., 3906432.,
      3917520., 3928608., 3939696., 3925656., 3936816., 3947976., 3959136.,
      4879710., 4893660., 4907610., 4921560., 4903560., 4917600., 4931640.,
      4945680., 5851368., 5868216., 5885064., 5901912., 5879772., 5896728.,
      5913684., 5930640., 4870890., 4885020., 4899150., 4913280., 4894380.,
      4908600., 4922820., 4937040., 3892320., 3903696., 3915072., 3926448.,
      3910968., 3922416., 3933864., 3945312.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      182928., 185712., 188496., 191280., 184056., 186864., 189672., 192480.,
      185184., 188016., 190848., 193680., 186312., 189168., 192024., 194880.,
      187440., 190320., 193200., 196080., 188568., 191472., 194376., 197280.,
      189696., 192624., 195552., 198480., 190824., 193776., 196728., 199680.,
      191952., 194928., 197904., 200880., 193080., 196080., 199080., 202080.,
      196464., 199536., 202608., 205680., 197592., 200688., 203784., 206880.,
      198720., 201840., 204960., 208080., 199848., 202992., 206136., 209280.,
      200976., 204144., 207312., 210480., 202104., 205296., 208488., 211680.,
      203232., 206448., 209664., 212880., 204360., 207600., 210840., 214080.,
      205488., 208752., 212016., 215280., 206616., 209904., 213192., 216480.,
      210000., 213360., 216720., 220080., 211128., 214512., 217896., 221280.,
      212256., 215664., 219072., 222480., 213384., 216816., 220248., 223680.,
      214512., 217968., 221424., 224880., 215640., 219120., 222600., 226080.,
      216768., 220272., 223776., 227280., 217896., 221424., 224952., 228480.,
      219024., 222576., 226128., 229680., 220152., 223728., 227304., 230880.,
      223536., 227184., 230832., 234480., 224664., 228336., 232008., 235680.,
      225792., 229488., 233184., 236880., 226920., 230640., 234360., 238080.,
      228048., 231792., 235536., 239280., 229176., 232944., 236712., 240480.,
      230304., 234096., 237888., 241680., 231432., 235248., 239064., 242880.,
      232560., 236400., 240240., 244080., 233688., 237552., 241416., 245280.,
      237072., 241008., 244944., 248880., 238200., 242160., 246120., 250080.,
      239328., 243312., 247296., 251280., 240456., 244464., 248472., 252480.,
      241584., 245616., 249648., 253680., 242712., 246768., 250824., 254880.,
      243840., 247920., 252000., 256080., 244968., 249072., 253176., 257280.,
      246096., 250224., 254352., 258480., 247224., 251376., 255528., 259680.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1955484., 1961208., 1966932., 1972656., 2447190., 2454300., 2461410.,
      2468520., 2939886., 2948364., 2956842., 2965320., 2451780., 2458800.,
      2465820., 2472840., 1962828., 1968408., 1973988., 1979568., 2306346.,
      2312772., 2319198., 2325624., 2884980., 2892960., 2900940., 2908920.,
      3464265., 3473778., 3483291., 3492804., 2887815., 2895690., 2903565.,
      2911440., 2310882., 2317140., 2323398., 2329656., 2659728., 2666784.,
      2673840., 2680896., 3325560., 3334320., 3343080., 3351840., 3991560.,
      4002000., 4012440., 4022880., 3325920., 3334560., 3343200., 3351840.,
      2660304., 2667168., 2674032., 2680896., 2311890., 2317812., 2323734.,
      2329656., 2889390., 2896740., 2904090., 2911440., 3466533., 3475290.,
      3484047., 3492804., 2887185., 2894430., 2901675., 2908920., 2308362.,
      2314116., 2319870., 2325624., 1964988., 1969848., 1974708., 1979568.,
      2454750., 2460780., 2466810., 2472840., 2943774., 2950956., 2958138.,
      2965320., 2450700., 2456640., 2462580., 2468520., 1958508., 1963224.,
      1967940., 1972656.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      95340.,  95640.,  95940.,  96240.,  96540.,  96840.,  97140.,  97440.,
      97740.,  98040.,  98340.,  98640.,  98940.,  99240.,  99540.,  99840.,
      100140., 100440., 100740., 101040., 102540., 102840., 103140., 103440.,
      103740., 104040., 104340., 104640., 104940., 105240., 105540., 105840.,
      106140., 106440., 106740., 107040., 107340., 107640., 107940., 108240.,
      109740., 110040., 110340., 110640., 110940., 111240., 111540., 111840.,
      112140., 112440., 112740., 113040., 113340., 113640., 113940., 114240.,
      114540., 114840., 115140., 115440., 116940., 117240., 117540., 117840.,
      118140., 118440., 118740., 119040., 119340., 119640., 119940., 120240.,
      120540., 120840., 121140., 121440., 121740., 122040., 122340., 122640.,
      124140., 124440., 124740., 125040., 125340., 125640., 125940., 126240.,
      126540., 126840., 127140., 127440., 127740., 128040., 128340., 128640.,
      128940., 129240., 129540., 129840.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3892320., 3910968., 3903696., 3922416., 3915072., 3933864., 3926448.,
      3945312., 4870890., 4894380., 4885020., 4908600., 4899150., 4922820.,
      4913280., 4937040., 5851368., 5879772., 5868216., 5896728., 5885064.,
      5913684., 5901912., 5930640., 4879710., 4903560., 4893660., 4917600.,
      4907610., 4931640., 4921560., 4945680., 3906432., 3925656., 3917520.,
      3936816., 3928608., 3947976., 3939696., 3959136., 4589928., 4612692.,
      4602696., 4625544., 4615464., 4638396., 4628232., 4651248., 5741295.,
      5769960., 5757150., 5785920., 5773005., 5801880., 5788860., 5817840.,
      6893880., 6928530., 6912780., 6947556., 6931680., 6966582., 6950580.,
      6985608., 5746545., 5775630., 5762190., 5791380., 5777835., 5807130.,
      5793480., 5822880., 4598328., 4621764., 4610760., 4634280., 4623192.,
      4646796., 4635624., 4659312., 5292288., 5319456., 5306304., 5333568.,
      5320320., 5347680., 5334336., 5361792., 6616920., 6651120., 6634320.,
      6668640., 6651720., 6686160., 6669120., 6703680., 7941792., 7983120.,
      7962528., 8004000., 7983264., 8024880., 8004000., 8045760., 6617160.,
      6651840., 6634320., 6669120., 6651480., 6686400., 6668640., 6703680.,
      5292672., 5320608., 5306304., 5334336., 5319936., 5348064., 5333568.,
      5361792., 4599000., 4623780., 4610760., 4635624., 4622520., 4647468.,
      4634280., 4659312., 5747595., 5778780., 5762190., 5793480., 5776785.,
      5808180., 5791380., 5822880., 6895392., 6933066., 6912780., 6950580.,
      6930168., 6968094., 6947556., 6985608., 5742765., 5774370., 5757150.,
      5788860., 5771535., 5803350., 5785920., 5817840., 4591272., 4616724.,
      4602696., 4628232., 4614120., 4639740., 4625544., 4651248., 3907872.,
      3929976., 3917520., 3939696., 3927168., 3949416., 3936816., 3959136.,
      4881690., 4909500., 4893660., 4921560., 4905630., 4933620., 4917600.,
      4945680., 5853960., 5887548., 5868216., 5901912., 5882472., 5916276.,
      5896728., 5930640., 4873230., 4901400., 4885020., 4913280., 4896810.,
      4925160., 4908600., 4937040., 3894336., 3917016., 3903696., 3926448.,
      3913056., 3935880., 3922416., 3945312.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      185136., 190680., 185712., 191280., 186288., 191880., 186864., 192480.,
      187440., 193080., 188016., 193680., 188592., 194280., 189168., 194880.,
      189744., 195480., 190320., 196080., 190896., 196680., 191472., 197280.,
      192048., 197880., 192624., 198480., 193200., 199080., 193776., 199680.,
      194352., 200280., 194928., 200880., 195504., 201480., 196080., 202080.,
      198960., 205080., 199536., 205680., 200112., 206280., 200688., 206880.,
      201264., 207480., 201840., 208080., 202416., 208680., 202992., 209280.,
      203568., 209880., 204144., 210480., 204720., 211080., 205296., 211680.,
      205872., 212280., 206448., 212880., 207024., 213480., 207600., 214080.,
      208176., 214680., 208752., 215280., 209328., 215880., 209904., 216480.,
      212784., 219480., 213360., 220080., 213936., 220680., 214512., 221280.,
      215088., 221880., 215664., 222480., 216240., 223080., 216816., 223680.,
      217392., 224280., 217968., 224880., 218544., 225480., 219120., 226080.,
      219696., 226680., 220272., 227280., 220848., 227880., 221424., 228480.,
      222000., 229080., 222576., 229680., 223152., 230280., 223728., 230880.,
      226608., 233880., 227184., 234480., 227760., 235080., 228336., 235680.,
      228912., 236280., 229488., 236880., 230064., 237480., 230640., 238080.,
      231216., 238680., 231792., 239280., 232368., 239880., 232944., 240480.,
      233520., 241080., 234096., 241680., 234672., 242280., 235248., 242880.,
      235824., 243480., 236400., 244080., 236976., 244680., 237552., 245280.,
      240432., 248280., 241008., 248880., 241584., 249480., 242160., 250080.,
      242736., 250680., 243312., 251280., 243888., 251880., 244464., 252480.,
      245040., 253080., 245616., 253680., 246192., 254280., 246768., 254880.,
      247344., 255480., 247920., 256080., 248496., 256680., 249072., 257280.,
      249648., 257880., 250224., 258480., 250800., 259080., 251376., 259680.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7765992.,  7784640.,  7803288.,  7821936.,  7788672.,  7807392.,
      7826112.,  7844832.,  7811352.,  7830144.,  7848936.,  7867728.,
      7834032.,  7852896.,  7871760.,  7890624.,  9718290.,  9741780.,
      9765270.,  9788760.,  9746460.,  9770040.,  9793620.,  9817200.,
      9774630.,  9798300.,  9821970.,  9845640.,  9802800.,  9826560.,
      9850320.,  9874080.,  11674332., 11702736., 11731140., 11759544.,
      11707920., 11736432., 11764944., 11793456., 11741508., 11770128.,
      11798748., 11827368., 11775096., 11803824., 11832552., 11861280.,
      9735570.,  9759420.,  9783270.,  9807120.,  9763380.,  9787320.,
      9811260.,  9835200.,  9791190.,  9815220.,  9839250.,  9863280.,
      9819000.,  9843120.,  9867240.,  9891360.,  7793640.,  7812864.,
      7832088.,  7851312.,  7815744.,  7835040.,  7854336.,  7873632.,
      7837848.,  7857216.,  7876584.,  7895952.,  7859952.,  7879392.,
      7898832.,  7918272.,  9157092.,  9179856.,  9202620.,  9225384.,
      9182544.,  9205392.,  9228240.,  9251088.,  9207996.,  9230928.,
      9253860.,  9276792.,  9233448.,  9256464.,  9279480.,  9302496.,
      11453925., 11482590., 11511255., 11539920., 11485530., 11514300.,
      11543070., 11571840., 11517135., 11546010., 11574885., 11603760.,
      11548740., 11577720., 11606700., 11635680., 13753110., 13787760.,
      13822410., 13857060., 13790784., 13825560., 13860336., 13895112.,
      13828458., 13863360., 13898262., 13933164., 13866132., 13901160.,
      13936188., 13971216., 11464005., 11493090., 11522175., 11551260.,
      11495190., 11524380., 11553570., 11582760., 11526375., 11555670.,
      11584965., 11614260., 11557560., 11586960., 11616360., 11645760.,
      9173220.,  9196656.,  9220092.,  9243528.,  9198000.,  9221520.,
      9245040.,  9268560.,  9222780.,  9246384.,  9269988.,  9293592.,
      9247560.,  9271248.,  9294936.,  9318624.,  10557408., 10584576.,
      10611744., 10638912., 10585344., 10612608., 10639872., 10667136.,
      10613280., 10640640., 10668000., 10695360., 10641216., 10668672.,
      10696128., 10723584., 13199640., 13233840., 13268040., 13302240.,
      13234320., 13268640., 13302960., 13337280., 13269000., 13303440.,
      13337880., 13372320., 13303680., 13338240., 13372800., 13407360.,
      15842256., 15883584., 15924912., 15966240., 15883584., 15925056.,
      15966528., 16008000., 15924912., 15966528., 16008144., 16049760.,
      15966240., 16008000., 16049760., 16091520., 13199640., 13234320.,
      13269000., 13303680., 13233840., 13268640., 13303440., 13338240.,
      13268040., 13302960., 13337880., 13372800., 13302240., 13337280.,
      13372320., 13407360., 10557408., 10585344., 10613280., 10641216.,
      10584576., 10612608., 10640640., 10668672., 10611744., 10639872.,
      10668000., 10696128., 10638912., 10667136., 10695360., 10723584.,
      9173220.,  9198000.,  9222780.,  9247560.,  9196656.,  9221520.,
      9246384.,  9271248.,  9220092.,  9245040.,  9269988.,  9294936.,
      9243528.,  9268560.,  9293592.,  9318624.,  11464005., 11495190.,
      11526375., 11557560., 11493090., 11524380., 11555670., 11586960.,
      11522175., 11553570., 11584965., 11616360., 11551260., 11582760.,
      11614260., 11645760., 13753110., 13790784., 13828458., 13866132.,
      13787760., 13825560., 13863360., 13901160., 13822410., 13860336.,
      13898262., 13936188., 13857060., 13895112., 13933164., 13971216.,
      11453925., 11485530., 11517135., 11548740., 11482590., 11514300.,
      11546010., 11577720., 11511255., 11543070., 11574885., 11606700.,
      11539920., 11571840., 11603760., 11635680., 9157092.,  9182544.,
      9207996.,  9233448.,  9179856.,  9205392.,  9230928.,  9256464.,
      9202620.,  9228240.,  9253860.,  9279480.,  9225384.,  9251088.,
      9276792.,  9302496.,  7793640.,  7815744.,  7837848.,  7859952.,
      7812864.,  7835040.,  7857216.,  7879392.,  7832088.,  7854336.,
      7876584.,  7898832.,  7851312.,  7873632.,  7895952.,  7918272.,
      9735570.,  9763380.,  9791190.,  9819000.,  9759420.,  9787320.,
      9815220.,  9843120.,  9783270.,  9811260.,  9839250.,  9867240.,
      9807120.,  9835200.,  9863280.,  9891360.,  11674332., 11707920.,
      11741508., 11775096., 11702736., 11736432., 11770128., 11803824.,
      11731140., 11764944., 11798748., 11832552., 11759544., 11793456.,
      11827368., 11861280., 9718290.,  9746460.,  9774630.,  9802800.,
      9741780.,  9770040.,  9798300.,  9826560.,  9765270.,  9793620.,
      9821970.,  9850320.,  9788760.,  9817200.,  9845640.,  9874080.,
      7765992.,  7788672.,  7811352.,  7834032.,  7784640.,  7807392.,
      7830144.,  7852896.,  7803288.,  7826112.,  7848936.,  7871760.,
      7821936.,  7844832.,  7867728.,  7890624.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      364728., 370272., 375816., 381360., 365856., 371424., 376992., 382560.,
      366984., 372576., 378168., 383760., 368112., 373728., 379344., 384960.,
      369240., 374880., 380520., 386160., 370368., 376032., 381696., 387360.,
      371496., 377184., 382872., 388560., 372624., 378336., 384048., 389760.,
      373752., 379488., 385224., 390960., 374880., 380640., 386400., 392160.,
      376008., 381792., 387576., 393360., 377136., 382944., 388752., 394560.,
      378264., 384096., 389928., 395760., 379392., 385248., 391104., 396960.,
      380520., 386400., 392280., 398160., 381648., 387552., 393456., 399360.,
      382776., 388704., 394632., 400560., 383904., 389856., 395808., 401760.,
      385032., 391008., 396984., 402960., 386160., 392160., 398160., 404160.,
      391800., 397920., 404040., 410160., 392928., 399072., 405216., 411360.,
      394056., 400224., 406392., 412560., 395184., 401376., 407568., 413760.,
      396312., 402528., 408744., 414960., 397440., 403680., 409920., 416160.,
      398568., 404832., 411096., 417360., 399696., 405984., 412272., 418560.,
      400824., 407136., 413448., 419760., 401952., 408288., 414624., 420960.,
      403080., 409440., 415800., 422160., 404208., 410592., 416976., 423360.,
      405336., 411744., 418152., 424560., 406464., 412896., 419328., 425760.,
      407592., 414048., 420504., 426960., 408720., 415200., 421680., 428160.,
      409848., 416352., 422856., 429360., 410976., 417504., 424032., 430560.,
      412104., 418656., 425208., 431760., 413232., 419808., 426384., 432960.,
      418872., 425568., 432264., 438960., 420000., 426720., 433440., 440160.,
      421128., 427872., 434616., 441360., 422256., 429024., 435792., 442560.,
      423384., 430176., 436968., 443760., 424512., 431328., 438144., 444960.,
      425640., 432480., 439320., 446160., 426768., 433632., 440496., 447360.,
      427896., 434784., 441672., 448560., 429024., 435936., 442848., 449760.,
      430152., 437088., 444024., 450960., 431280., 438240., 445200., 452160.,
      432408., 439392., 446376., 453360., 433536., 440544., 447552., 454560.,
      434664., 441696., 448728., 455760., 435792., 442848., 449904., 456960.,
      436920., 444000., 451080., 458160., 438048., 445152., 452256., 459360.,
      439176., 446304., 453432., 460560., 440304., 447456., 454608., 461760.,
      445944., 453216., 460488., 467760., 447072., 454368., 461664., 468960.,
      448200., 455520., 462840., 470160., 449328., 456672., 464016., 471360.,
      450456., 457824., 465192., 472560., 451584., 458976., 466368., 473760.,
      452712., 460128., 467544., 474960., 453840., 461280., 468720., 476160.,
      454968., 462432., 469896., 477360., 456096., 463584., 471072., 478560.,
      457224., 464736., 472248., 479760., 458352., 465888., 473424., 480960.,
      459480., 467040., 474600., 482160., 460608., 468192., 475776., 483360.,
      461736., 469344., 476952., 484560., 462864., 470496., 478128., 485760.,
      463992., 471648., 479304., 486960., 465120., 472800., 480480., 488160.,
      466248., 473952., 481656., 489360., 467376., 475104., 482832., 490560.,
      473016., 480864., 488712., 496560., 474144., 482016., 489888., 497760.,
      475272., 483168., 491064., 498960., 476400., 484320., 492240., 500160.,
      477528., 485472., 493416., 501360., 478656., 486624., 494592., 502560.,
      479784., 487776., 495768., 503760., 480912., 488928., 496944., 504960.,
      482040., 490080., 498120., 506160., 483168., 491232., 499296., 507360.,
      484296., 492384., 500472., 508560., 485424., 493536., 501648., 509760.,
      486552., 494688., 502824., 510960., 487680., 495840., 504000., 512160.,
      488808., 496992., 505176., 513360., 489936., 498144., 506352., 514560.,
      491064., 499296., 507528., 515760., 492192., 500448., 508704., 516960.,
      493320., 501600., 509880., 518160., 494448., 502752., 511056., 519360.};
  const std::array<int, 4> in_shape = {{3, 8, 6, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      838065.,  1006614., 1175433., 1008126., 840585.,  987910.,  1186143.,
      1384544., 1187025., 989380.,  1138700., 1366680., 1594684., 1366680.,
      1138700., 989380.,  1187025., 1384544., 1186143., 987910.,  840585.,
      1008126., 1175433., 1006614., 838065.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      62718., 63384., 64050., 64716., 65382., 67380., 68046., 68712., 69378.,
      70044., 72042., 72708., 73374., 74040., 74706., 76704., 77370., 78036.,
      78702., 79368., 81366., 82032., 82698., 83364., 84030.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1669245., 1676130., 2004912., 2013228., 2341101., 2350866., 2007828.,
      2016252., 1674105., 1681170., 1967420., 1975820., 2362143., 2372286.,
      2757181., 2769088., 2363781., 2374050., 1970150., 1978760., 2267380.,
      2277400., 2721264., 2733360., 3175172., 3189368., 2721120., 2733360.,
      2267140., 2277400., 1969625., 1978760., 2363025., 2374050., 2756152.,
      2769088., 2361135., 2372286., 1966475., 1975820., 1673025., 1681170.,
      2006424., 2016252., 2339337., 2350866., 2003292., 2013228., 1667805.,
      1676130.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      122970., 125436., 124266., 126768., 125562., 128100., 126858., 129432.,
      128154., 130764., 132042., 134760., 133338., 136092., 134634., 137424.,
      135930., 138756., 137226., 140088., 141114., 144084., 142410., 145416.,
      143706., 146748., 145002., 148080., 146298., 149412., 150186., 153408.,
      151482., 154740., 152778., 156072., 154074., 157404., 155370., 158736.,
      159258., 162732., 160554., 164064., 161850., 165396., 163146., 166728.,
      164442., 168060.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3331605., 3338490., 3345375., 3352260., 4001508., 4009824., 4018140.,
      4026456., 4672437., 4682202., 4691967., 4701732., 4007232., 4015656.,
      4024080., 4032504., 3341145., 3348210., 3355275., 3362340., 3926440.,
      3934840., 3943240., 3951640., 4714143., 4724286., 4734429., 4744572.,
      5502455., 5514362., 5526269., 5538176., 4717293., 4727562., 4737831.,
      4748100., 3931690., 3940300., 3948910., 3957520., 4524740., 4534760.,
      4544780., 4554800., 5430432., 5442528., 5454624., 5466720., 6336148.,
      6350344., 6364540., 6378736., 5430000., 5442240., 5454480., 5466720.,
      4524020., 4534280., 4544540., 4554800., 3930115., 3939250., 3948385.,
      3957520., 4715025., 4726050., 4737075., 4748100., 5499368., 5512304.,
      5525240., 5538176., 4711119., 4722270., 4733421., 4744572., 3923605.,
      3932950., 3942295., 3951640., 3337905., 3346050., 3354195., 3362340.,
      4003020., 4012848., 4022676., 4032504., 4667145., 4678674., 4690203.,
      4701732., 3996648., 4006584., 4016520., 4026456., 3327285., 3335610.,
      3343935., 3352260.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      243474., 245940., 248406., 250872., 246030., 248532., 251034., 253536.,
      248586., 251124., 253662., 256200., 251142., 253716., 256290., 258864.,
      253698., 256308., 258918., 261528., 261366., 264084., 266802., 269520.,
      263922., 266676., 269430., 272184., 266478., 269268., 272058., 274848.,
      269034., 271860., 274686., 277512., 271590., 274452., 277314., 280176.,
      279258., 282228., 285198., 288168., 281814., 284820., 287826., 290832.,
      284370., 287412., 290454., 293496., 286926., 290004., 293082., 296160.,
      289482., 292596., 295710., 298824., 297150., 300372., 303594., 306816.,
      299706., 302964., 306222., 309480., 302262., 305556., 308850., 312144.,
      304818., 308148., 311478., 314808., 307374., 310740., 314106., 317472.,
      315042., 318516., 321990., 325464., 317598., 321108., 324618., 328128.,
      320154., 323700., 327246., 330792., 322710., 326292., 329874., 333456.,
      325266., 328884., 332502., 336120.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1667805., 1676130., 2003292., 2013228., 2339337., 2350866., 2006424.,
      2016252., 1673025., 1681170., 1966475., 1975820., 2361135., 2372286.,
      2756152., 2769088., 2363025., 2374050., 1969625., 1978760., 2267140.,
      2277400., 2721120., 2733360., 3175172., 3189368., 2721264., 2733360.,
      2267380., 2277400., 1970150., 1978760., 2363781., 2374050., 2757181.,
      2769088., 2362143., 2372286., 1967420., 1975820., 1674105., 1681170.,
      2007828., 2016252., 2341101., 2350866., 2004912., 2013228., 1669245.,
      1676130.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      124770., 125436., 126102., 126768., 127434., 128100., 128766., 129432.,
      130098., 130764., 134094., 134760., 135426., 136092., 136758., 137424.,
      138090., 138756., 139422., 140088., 143418., 144084., 144750., 145416.,
      146082., 146748., 147414., 148080., 148746., 149412., 152742., 153408.,
      154074., 154740., 155406., 156072., 156738., 157404., 158070., 158736.,
      162066., 162732., 163398., 164064., 164730., 165396., 166062., 166728.,
      167394., 168060.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3321930., 3335610., 3338490., 3352260., 3990060., 4006584., 4009824.,
      4026456., 4659270., 4678674., 4682202., 4701732., 3996108., 4012848.,
      4015656., 4032504., 3332010., 3346050., 3348210., 3362340., 3916255.,
      3932950., 3934840., 3951640., 4702110., 4722270., 4724286., 4744572.,
      5488637., 5512304., 5514362., 5538176., 4705638., 4726050., 4727562.,
      4748100., 3922135., 3939250., 3940300., 3957520., 4514360., 4534280.,
      4534760., 4554800., 5418192., 5442240., 5442528., 5466720., 6322120.,
      6350344., 6350344., 6378736., 5418192., 5442528., 5442240., 5466720.,
      4514360., 4534760., 4534280., 4554800., 3922135., 3940300., 3939250.,
      3957520., 4705638., 4727562., 4726050., 4748100., 5488637., 5514362.,
      5512304., 5538176., 4702110., 4724286., 4722270., 4744572., 3916255.,
      3934840., 3932950., 3951640., 3332010., 3348210., 3346050., 3362340.,
      3996108., 4015656., 4012848., 4032504., 4659270., 4682202., 4678674.,
      4701732., 3990060., 4009824., 4006584., 4026456., 3321930., 3338490.,
      3335610., 3352260.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      244644., 249540., 245940., 250872., 247236., 252204., 248532., 253536.,
      249828., 254868., 251124., 256200., 252420., 257532., 253716., 258864.,
      255012., 260196., 256308., 261528., 262788., 268188., 264084., 269520.,
      265380., 270852., 266676., 272184., 267972., 273516., 269268., 274848.,
      270564., 276180., 271860., 277512., 273156., 278844., 274452., 280176.,
      280932., 286836., 282228., 288168., 283524., 289500., 284820., 290832.,
      286116., 292164., 287412., 293496., 288708., 294828., 290004., 296160.,
      291300., 297492., 292596., 298824., 299076., 305484., 300372., 306816.,
      301668., 308148., 302964., 309480., 304260., 310812., 305556., 312144.,
      306852., 313476., 308148., 314808., 309444., 316140., 310740., 317472.,
      317220., 324132., 318516., 325464., 319812., 326796., 321108., 328128.,
      322404., 329460., 323700., 330792., 324996., 332124., 326292., 333456.,
      327588., 334788., 328884., 336120.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6630180.,  6643860.,  6657540.,  6671220.,  6663210.,  6676980.,
      6690750.,  6704520.,  7963596.,  7980120.,  7996644.,  8013168.,
      8003016.,  8019648.,  8036280.,  8052912.,  9299136.,  9318540.,
      9337944.,  9357348.,  9344874.,  9364404.,  9383934.,  9403464.,
      7975476.,  7992216.,  8008956.,  8025696.,  8014464.,  8031312.,
      8048160.,  8065008.,  6649980.,  6664020.,  6678060.,  6692100.,
      6682290.,  6696420.,  6710550.,  6724680.,  7815815.,  7832510.,
      7849205.,  7865900.,  7852880.,  7869680.,  7886480.,  7903280.,
      9384060.,  9404220.,  9424380.,  9444540.,  9428286.,  9448572.,
      9468858.,  9489144.,  10953607., 10977274., 11000941., 11024608.,
      11004910., 11028724., 11052538., 11076352., 9390864.,  9411276.,
      9431688.,  9452100.,  9434586.,  9455124.,  9475662.,  9496200.,
      7827155.,  7844270.,  7861385.,  7878500.,  7863380.,  7880600.,
      7897820.,  7915040.,  9008800.,  9028720.,  9048640.,  9068560.,
      9049480.,  9069520.,  9089560.,  9109600.,  10812336., 10836384.,
      10860432., 10884480., 10860864., 10885056., 10909248., 10933440.,
      12616016., 12644240., 12672464., 12700688., 12672296., 12700688.,
      12729080., 12757472., 10812048., 10836384., 10860720., 10885056.,
      10860000., 10884480., 10908960., 10933440., 9008320.,  9028720.,
      9049120.,  9069520.,  9048040.,  9068560.,  9089080.,  9109600.,
      7826105.,  7844270.,  7862435.,  7880600.,  7860230.,  7878500.,
      7896770.,  7915040.,  9389352.,  9411276.,  9433200.,  9455124.,
      9430050.,  9452100.,  9474150.,  9496200.,  10951549., 10977274.,
      11002999., 11028724., 10998736., 11024608., 11050480., 11076352.,
      9382044.,  9404220.,  9426396.,  9448572.,  9422238.,  9444540.,
      9466842.,  9489144.,  7813925.,  7832510.,  7851095.,  7869680.,
      7847210.,  7865900.,  7884590.,  7903280.,  6647820.,  6664020.,
      6680220.,  6696420.,  6675810.,  6692100.,  6708390.,  6724680.,
      7972668.,  7992216.,  8011764.,  8031312.,  8006040.,  8025696.,
      8045352.,  8065008.,  9295608.,  9318540.,  9341472.,  9364404.,
      9334290.,  9357348.,  9380406.,  9403464.,  7960356.,  7980120.,
      7999884.,  8019648.,  7993296.,  8013168.,  8033040.,  8052912.,
      6627300.,  6643860.,  6660420.,  6676980.,  6654570.,  6671220.,
      6687870.,  6704520.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      484392., 489288., 494184., 499080., 486948., 491880., 496812., 501744.,
      489504., 494472., 499440., 504408., 492060., 497064., 502068., 507072.,
      494616., 499656., 504696., 509736., 497172., 502248., 507324., 512400.,
      499728., 504840., 509952., 515064., 502284., 507432., 512580., 517728.,
      504840., 510024., 515208., 520392., 507396., 512616., 517836., 523056.,
      520176., 525576., 530976., 536376., 522732., 528168., 533604., 539040.,
      525288., 530760., 536232., 541704., 527844., 533352., 538860., 544368.,
      530400., 535944., 541488., 547032., 532956., 538536., 544116., 549696.,
      535512., 541128., 546744., 552360., 538068., 543720., 549372., 555024.,
      540624., 546312., 552000., 557688., 543180., 548904., 554628., 560352.,
      555960., 561864., 567768., 573672., 558516., 564456., 570396., 576336.,
      561072., 567048., 573024., 579000., 563628., 569640., 575652., 581664.,
      566184., 572232., 578280., 584328., 568740., 574824., 580908., 586992.,
      571296., 577416., 583536., 589656., 573852., 580008., 586164., 592320.,
      576408., 582600., 588792., 594984., 578964., 585192., 591420., 597648.,
      591744., 598152., 604560., 610968., 594300., 600744., 607188., 613632.,
      596856., 603336., 609816., 616296., 599412., 605928., 612444., 618960.,
      601968., 608520., 615072., 621624., 604524., 611112., 617700., 624288.,
      607080., 613704., 620328., 626952., 609636., 616296., 622956., 629616.,
      612192., 618888., 625584., 632280., 614748., 621480., 628212., 634944.,
      627528., 634440., 641352., 648264., 630084., 637032., 643980., 650928.,
      632640., 639624., 646608., 653592., 635196., 642216., 649236., 656256.,
      637752., 644808., 651864., 658920., 640308., 647400., 654492., 661584.,
      642864., 649992., 657120., 664248., 645420., 652584., 659748., 666912.,
      647976., 655176., 662376., 669576., 650532., 657768., 665004., 672240.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3327285., 3335610., 3343935., 3352260., 3996648., 4006584., 4016520.,
      4026456., 4667145., 4678674., 4690203., 4701732., 4003020., 4012848.,
      4022676., 4032504., 3337905., 3346050., 3354195., 3362340., 3923605.,
      3932950., 3942295., 3951640., 4711119., 4722270., 4733421., 4744572.,
      5499368., 5512304., 5525240., 5538176., 4715025., 4726050., 4737075.,
      4748100., 3930115., 3939250., 3948385., 3957520., 4524020., 4534280.,
      4544540., 4554800., 5430000., 5442240., 5454480., 5466720., 6336148.,
      6350344., 6364540., 6378736., 5430432., 5442528., 5454624., 5466720.,
      4524740., 4534760., 4544780., 4554800., 3931690., 3940300., 3948910.,
      3957520., 4717293., 4727562., 4737831., 4748100., 5502455., 5514362.,
      5526269., 5538176., 4714143., 4724286., 4734429., 4744572., 3926440.,
      3934840., 3943240., 3951640., 3341145., 3348210., 3355275., 3362340.,
      4007232., 4015656., 4024080., 4032504., 4672437., 4682202., 4691967.,
      4701732., 4001508., 4009824., 4018140., 4026456., 3331605., 3338490.,
      3345375., 3352260.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      248874., 249540., 250206., 250872., 251538., 252204., 252870., 253536.,
      254202., 254868., 255534., 256200., 256866., 257532., 258198., 258864.,
      259530., 260196., 260862., 261528., 267522., 268188., 268854., 269520.,
      270186., 270852., 271518., 272184., 272850., 273516., 274182., 274848.,
      275514., 276180., 276846., 277512., 278178., 278844., 279510., 280176.,
      286170., 286836., 287502., 288168., 288834., 289500., 290166., 290832.,
      291498., 292164., 292830., 293496., 294162., 294828., 295494., 296160.,
      296826., 297492., 298158., 298824., 304818., 305484., 306150., 306816.,
      307482., 308148., 308814., 309480., 310146., 310812., 311478., 312144.,
      312810., 313476., 314142., 314808., 315474., 316140., 316806., 317472.,
      323466., 324132., 324798., 325464., 326130., 326796., 327462., 328128.,
      328794., 329460., 330126., 330792., 331458., 332124., 332790., 333456.,
      334122., 334788., 335454., 336120.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6627300.,  6654570.,  6643860.,  6671220.,  6660420.,  6687870.,
      6676980.,  6704520.,  7960356.,  7993296.,  7980120.,  8013168.,
      7999884.,  8033040.,  8019648.,  8052912.,  9295608.,  9334290.,
      9318540.,  9357348.,  9341472.,  9380406.,  9364404.,  9403464.,
      7972668.,  8006040.,  7992216.,  8025696.,  8011764.,  8045352.,
      8031312.,  8065008.,  6647820.,  6675810.,  6664020.,  6692100.,
      6680220.,  6708390.,  6696420.,  6724680.,  7813925.,  7847210.,
      7832510.,  7865900.,  7851095.,  7884590.,  7869680.,  7903280.,
      9382044.,  9422238.,  9404220.,  9444540.,  9426396.,  9466842.,
      9448572.,  9489144.,  10951549., 10998736., 10977274., 11024608.,
      11002999., 11050480., 11028724., 11076352., 9389352.,  9430050.,
      9411276.,  9452100.,  9433200.,  9474150.,  9455124.,  9496200.,
      7826105.,  7860230.,  7844270.,  7878500.,  7862435.,  7896770.,
      7880600.,  7915040.,  9008320.,  9048040.,  9028720.,  9068560.,
      9049120.,  9089080.,  9069520.,  9109600.,  10812048., 10860000.,
      10836384., 10884480., 10860720., 10908960., 10885056., 10933440.,
      12616016., 12672296., 12644240., 12700688., 12672464., 12729080.,
      12700688., 12757472., 10812336., 10860864., 10836384., 10885056.,
      10860432., 10909248., 10884480., 10933440., 9008800.,  9049480.,
      9028720.,  9069520.,  9048640.,  9089560.,  9068560.,  9109600.,
      7827155.,  7863380.,  7844270.,  7880600.,  7861385.,  7897820.,
      7878500.,  7915040.,  9390864.,  9434586.,  9411276.,  9455124.,
      9431688.,  9475662.,  9452100.,  9496200.,  10953607., 11004910.,
      10977274., 11028724., 11000941., 11052538., 11024608., 11076352.,
      9384060.,  9428286.,  9404220.,  9448572.,  9424380.,  9468858.,
      9444540.,  9489144.,  7815815.,  7852880.,  7832510.,  7869680.,
      7849205.,  7886480.,  7865900.,  7903280.,  6649980.,  6682290.,
      6664020.,  6696420.,  6678060.,  6710550.,  6692100.,  6724680.,
      7975476.,  8014464.,  7992216.,  8031312.,  8008956.,  8048160.,
      8025696.,  8065008.,  9299136.,  9344874.,  9318540.,  9364404.,
      9337944.,  9383934.,  9357348.,  9403464.,  7963596.,  8003016.,
      7980120.,  8019648.,  7996644.,  8036280.,  8013168.,  8052912.,
      6630180.,  6663210.,  6643860.,  6676980.,  6657540.,  6690750.,
      6671220.,  6704520.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      487992., 497748., 489288., 499080., 490584., 500412., 491880., 501744.,
      493176., 503076., 494472., 504408., 495768., 505740., 497064., 507072.,
      498360., 508404., 499656., 509736., 500952., 511068., 502248., 512400.,
      503544., 513732., 504840., 515064., 506136., 516396., 507432., 517728.,
      508728., 519060., 510024., 520392., 511320., 521724., 512616., 523056.,
      524280., 535044., 525576., 536376., 526872., 537708., 528168., 539040.,
      529464., 540372., 530760., 541704., 532056., 543036., 533352., 544368.,
      534648., 545700., 535944., 547032., 537240., 548364., 538536., 549696.,
      539832., 551028., 541128., 552360., 542424., 553692., 543720., 555024.,
      545016., 556356., 546312., 557688., 547608., 559020., 548904., 560352.,
      560568., 572340., 561864., 573672., 563160., 575004., 564456., 576336.,
      565752., 577668., 567048., 579000., 568344., 580332., 569640., 581664.,
      570936., 582996., 572232., 584328., 573528., 585660., 574824., 586992.,
      576120., 588324., 577416., 589656., 578712., 590988., 580008., 592320.,
      581304., 593652., 582600., 594984., 583896., 596316., 585192., 597648.,
      596856., 609636., 598152., 610968., 599448., 612300., 600744., 613632.,
      602040., 614964., 603336., 616296., 604632., 617628., 605928., 618960.,
      607224., 620292., 608520., 621624., 609816., 622956., 611112., 624288.,
      612408., 625620., 613704., 626952., 615000., 628284., 616296., 629616.,
      617592., 630948., 618888., 632280., 620184., 633612., 621480., 634944.,
      633144., 646932., 634440., 648264., 635736., 649596., 637032., 650928.,
      638328., 652260., 639624., 653592., 640920., 654924., 642216., 656256.,
      643512., 657588., 644808., 658920., 646104., 660252., 647400., 661584.,
      648696., 662916., 649992., 664248., 651288., 665580., 652584., 666912.,
      653880., 668244., 655176., 669576., 656472., 670908., 657768., 672240.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4097346.,  4115400.,  4133454.,  4151508.,  4115016.,  4133160.,
      4151304.,  4169448.,  4132686.,  4150920.,  4169154.,  4187388.,
      4150356.,  4168680.,  4187004.,  4205328.,  5133212.,  5154888.,
      5176564.,  5198240.,  5154712.,  5176496.,  5198280.,  5220064.,
      5176212.,  5198104.,  5219996.,  5241888.,  5197712.,  5219712.,
      5241712.,  5263712.,  6171350.,  6196720.,  6222090.,  6247460.,
      6196608.,  6222104.,  6247600.,  6273096.,  6221866.,  6247488.,
      6273110.,  6298732.,  6247124.,  6272872.,  6298620.,  6324368.,
      5337628.,  5359224.,  5380820.,  5402416.,  5359208.,  5380912.,
      5402616.,  5424320.,  5380788.,  5402600.,  5424412.,  5446224.,
      5402368.,  5424288.,  5446208.,  5468128.,  4506306.,  4524056.,
      4541806.,  4559556.,  4524280.,  4542120.,  4559960.,  4577800.,
      4542254.,  4560184.,  4578114.,  4596044.,  4560228.,  4578248.,
      4596268.,  4614288.,  5911109.,  5932618.,  5954127.,  5975636.,
      5932814.,  5954428.,  5976042.,  5997656.,  5954519.,  5976238.,
      5997957.,  6019676.,  5976224.,  5998048.,  6019872.,  6041696.,
      7331382.,  7357240.,  7383098.,  7408956.,  7357688.,  7383672.,
      7409656.,  7435640.,  7383994.,  7410104.,  7436214.,  7462324.,
      7410300.,  7436536.,  7462772.,  7489008.,  8754343.,  8784634.,
      8814925.,  8845216.,  8785166.,  8815604.,  8846042.,  8876480.,
      8815989.,  8846574.,  8877159.,  8907744.,  8846812.,  8877544.,
      8908276.,  8939008.,  7566678.,  7592528.,  7618378.,  7644228.,
      7592992.,  7618968.,  7644944.,  7670920.,  7619306.,  7645408.,
      7671510.,  7697612.,  7645620.,  7671848.,  7698076.,  7724304.,
      6381093.,  6402418.,  6423743.,  6445068.,  6402982.,  6424412.,
      6445842.,  6467272.,  6424871.,  6446406.,  6467941.,  6489476.,
      6446760.,  6468400.,  6490040.,  6511680.,  7811672.,  7837056.,
      7862440.,  7887824.,  7836992.,  7862496.,  7888000.,  7913504.,
      7862312.,  7887936.,  7913560.,  7939184.,  7887632.,  7913376.,
      7939120.,  7964864.,  9631696.,  9662240.,  9692784.,  9723328.,
      9662304.,  9692992.,  9723680.,  9754368.,  9692912.,  9723744.,
      9754576.,  9785408.,  9723520.,  9754496.,  9785472.,  9816448.,
      11454152., 11489952., 11525752., 11561552., 11489952., 11525920.,
      11561888., 11597856., 11525752., 11561888., 11598024., 11634160.,
      11561552., 11597856., 11634160., 11670464., 9631696.,  9662304.,
      9692912.,  9723520.,  9662240.,  9692992.,  9723744.,  9754496.,
      9692784.,  9723680.,  9754576.,  9785472.,  9723328.,  9754368.,
      9785408.,  9816448.,  7811672.,  7836992.,  7862312.,  7887632.,
      7837056.,  7862496.,  7887936.,  7913376.,  7862440.,  7888000.,
      7913560.,  7939120.,  7887824.,  7913504.,  7939184.,  7964864.,
      6381093.,  6402982.,  6424871.,  6446760.,  6402418.,  6424412.,
      6446406.,  6468400.,  6423743.,  6445842.,  6467941.,  6490040.,
      6445068.,  6467272.,  6489476.,  6511680.,  7566678.,  7592992.,
      7619306.,  7645620.,  7592528.,  7618968.,  7645408.,  7671848.,
      7618378.,  7644944.,  7671510.,  7698076.,  7644228.,  7670920.,
      7697612.,  7724304.,  8754343.,  8785166.,  8815989.,  8846812.,
      8784634.,  8815604.,  8846574.,  8877544.,  8814925.,  8846042.,
      8877159.,  8908276.,  8845216.,  8876480.,  8907744.,  8939008.,
      7331382.,  7357688.,  7383994.,  7410300.,  7357240.,  7383672.,
      7410104.,  7436536.,  7383098.,  7409656.,  7436214.,  7462772.,
      7408956.,  7435640.,  7462324.,  7489008.,  5911109.,  5932814.,
      5954519.,  5976224.,  5932618.,  5954428.,  5976238.,  5998048.,
      5954127.,  5976042.,  5997957.,  6019872.,  5975636.,  5997656.,
      6019676.,  6041696.,  4506306.,  4524280.,  4542254.,  4560228.,
      4524056.,  4542120.,  4560184.,  4578248.,  4541806.,  4559960.,
      4578114.,  4596268.,  4559556.,  4577800.,  4596044.,  4614288.,
      5337628.,  5359208.,  5380788.,  5402368.,  5359224.,  5380912.,
      5402600.,  5424288.,  5380820.,  5402616.,  5424412.,  5446208.,
      5402416.,  5424320.,  5446224.,  5468128.,  6171350.,  6196608.,
      6221866.,  6247124.,  6196720.,  6222104.,  6247488.,  6272872.,
      6222090.,  6247600.,  6273110.,  6298620.,  6247460.,  6273096.,
      6298732.,  6324368.,  5133212.,  5154712.,  5176212.,  5197712.,
      5154888.,  5176496.,  5198104.,  5219712.,  5176564.,  5198280.,
      5219996.,  5241712.,  5198240.,  5220064.,  5241888.,  5263712.,
      4097346.,  4115016.,  4132686.,  4150356.,  4115400.,  4133160.,
      4150920.,  4168680.,  4133454.,  4151304.,  4169154.,  4187004.,
      4151508.,  4169448.,  4187388.,  4205328.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x7x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      966228.,  975984.,  985740.,  995496.,  968784.,  978576.,  988368.,
      998160.,  971340.,  981168.,  990996.,  1000824., 973896.,  983760.,
      993624.,  1003488., 976452.,  986352.,  996252.,  1006152., 979008.,
      988944.,  998880.,  1008816., 981564.,  991536.,  1001508., 1011480.,
      984120.,  994128.,  1004136., 1014144., 986676.,  996720.,  1006764.,
      1016808., 989232.,  999312.,  1009392., 1019472., 991788.,  1001904.,
      1012020., 1022136., 994344.,  1004496., 1014648., 1024800., 996900.,
      1007088., 1017276., 1027464., 999456.,  1009680., 1019904., 1030128.,
      1002012., 1012272., 1022532., 1032792., 1004568., 1014864., 1025160.,
      1035456., 1007124., 1017456., 1027788., 1038120., 1009680., 1020048.,
      1030416., 1040784., 1012236., 1022640., 1033044., 1043448., 1014792.,
      1025232., 1035672., 1046112., 1037796., 1048560., 1059324., 1070088.,
      1040352., 1051152., 1061952., 1072752., 1042908., 1053744., 1064580.,
      1075416., 1045464., 1056336., 1067208., 1078080., 1048020., 1058928.,
      1069836., 1080744., 1050576., 1061520., 1072464., 1083408., 1053132.,
      1064112., 1075092., 1086072., 1055688., 1066704., 1077720., 1088736.,
      1058244., 1069296., 1080348., 1091400., 1060800., 1071888., 1082976.,
      1094064., 1063356., 1074480., 1085604., 1096728., 1065912., 1077072.,
      1088232., 1099392., 1068468., 1079664., 1090860., 1102056., 1071024.,
      1082256., 1093488., 1104720., 1073580., 1084848., 1096116., 1107384.,
      1076136., 1087440., 1098744., 1110048., 1078692., 1090032., 1101372.,
      1112712., 1081248., 1092624., 1104000., 1115376., 1083804., 1095216.,
      1106628., 1118040., 1086360., 1097808., 1109256., 1120704., 1109364.,
      1121136., 1132908., 1144680., 1111920., 1123728., 1135536., 1147344.,
      1114476., 1126320., 1138164., 1150008., 1117032., 1128912., 1140792.,
      1152672., 1119588., 1131504., 1143420., 1155336., 1122144., 1134096.,
      1146048., 1158000., 1124700., 1136688., 1148676., 1160664., 1127256.,
      1139280., 1151304., 1163328., 1129812., 1141872., 1153932., 1165992.,
      1132368., 1144464., 1156560., 1168656., 1134924., 1147056., 1159188.,
      1171320., 1137480., 1149648., 1161816., 1173984., 1140036., 1152240.,
      1164444., 1176648., 1142592., 1154832., 1167072., 1179312., 1145148.,
      1157424., 1169700., 1181976., 1147704., 1160016., 1172328., 1184640.,
      1150260., 1162608., 1174956., 1187304., 1152816., 1165200., 1177584.,
      1189968., 1155372., 1167792., 1180212., 1192632., 1157928., 1170384.,
      1182840., 1195296., 1180932., 1193712., 1206492., 1219272., 1183488.,
      1196304., 1209120., 1221936., 1186044., 1198896., 1211748., 1224600.,
      1188600., 1201488., 1214376., 1227264., 1191156., 1204080., 1217004.,
      1229928., 1193712., 1206672., 1219632., 1232592., 1196268., 1209264.,
      1222260., 1235256., 1198824., 1211856., 1224888., 1237920., 1201380.,
      1214448., 1227516., 1240584., 1203936., 1217040., 1230144., 1243248.,
      1206492., 1219632., 1232772., 1245912., 1209048., 1222224., 1235400.,
      1248576., 1211604., 1224816., 1238028., 1251240., 1214160., 1227408.,
      1240656., 1253904., 1216716., 1230000., 1243284., 1256568., 1219272.,
      1232592., 1245912., 1259232., 1221828., 1235184., 1248540., 1261896.,
      1224384., 1237776., 1251168., 1264560., 1226940., 1240368., 1253796.,
      1267224., 1229496., 1242960., 1256424., 1269888., 1252500., 1266288.,
      1280076., 1293864., 1255056., 1268880., 1282704., 1296528., 1257612.,
      1271472., 1285332., 1299192., 1260168., 1274064., 1287960., 1301856.,
      1262724., 1276656., 1290588., 1304520., 1265280., 1279248., 1293216.,
      1307184., 1267836., 1281840., 1295844., 1309848., 1270392., 1284432.,
      1298472., 1312512., 1272948., 1287024., 1301100., 1315176., 1275504.,
      1289616., 1303728., 1317840., 1278060., 1292208., 1306356., 1320504.,
      1280616., 1294800., 1308984., 1323168., 1283172., 1297392., 1311612.,
      1325832., 1285728., 1299984., 1314240., 1328496., 1288284., 1302576.,
      1316868., 1331160., 1290840., 1305168., 1319496., 1333824., 1293396.,
      1307760., 1322124., 1336488., 1295952., 1310352., 1324752., 1339152.,
      1298508., 1312944., 1327380., 1341816., 1301064., 1315536., 1330008.,
      1344480.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1312362., 1532328., 1752600., 1534344., 1315818., 1546881., 1805552.,
      2064412., 1806728., 1548897., 1782840., 2080288., 2377760., 2080288.,
      1782840., 1548897., 1806728., 2064412., 1805552., 1546881., 1315818.,
      1534344., 1752600., 1532328., 1312362.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      127064., 128240., 129416., 130592., 131768., 136472., 137648.,
      138824., 140000., 141176., 145880., 147056., 148232., 149408.,
      150584., 155288., 156464., 157640., 158816., 159992., 164696.,
      165872., 167048., 168224., 169400.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2615274., 2624724., 3053568., 3064656., 3492456., 3505200., 3057474.,
      3068688., 2621970., 2631636., 3082233., 3093762., 3597580., 3611104.,
      4113284., 4128824., 3599785., 3613456., 3086013., 3097794., 3551928.,
      3565680., 4144448., 4160576., 4736992., 4755520., 4144280., 4160576.,
      3551640., 3565680., 3085257., 3097794., 3598756., 3613456., 4111940.,
      4128824., 3596257., 3611104., 3080973., 3093762., 2620458., 2631636.,
      3055584., 3068688., 3490152., 3505200., 3051426., 3064656., 2613330.,
      2624724.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      250360., 254128., 252664., 256480., 254968., 258832., 257272., 261184.,
      259576., 263536., 268792., 272944., 271096., 275296., 273400., 277648.,
      275704., 280000., 278008., 282352., 287224., 291760., 289528., 294112.,
      291832., 296464., 294136., 298816., 296440., 301168., 305656., 310576.,
      307960., 312928., 310264., 315280., 312568., 317632., 314872., 319984.,
      324088., 329392., 326392., 331744., 328696., 334096., 331000., 336448.,
      333304., 338800.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5221098., 5230548., 5239998., 5249448., 6096048., 6107136., 6118224.,
      6129312., 6972168., 6984912., 6997656., 7010400., 6103734., 6114948.,
      6126162., 6137376., 5234274., 5243940., 5253606., 5263272., 6152937.,
      6164466., 6175995., 6187524., 7181636., 7195160., 7208684., 7222208.,
      8211028., 8226568., 8242108., 8257648., 7185899., 7199570., 7213241.,
      7226912., 6160245., 6172026., 6183807., 6195588., 7090104., 7103856.,
      7117608., 7131360., 8272768., 8288896., 8305024., 8321152., 9455456.,
      9473984., 9492512., 9511040., 8272264., 8288560., 8304856., 8321152.,
      7089240., 7103280., 7117320., 7131360., 6157977., 6170514., 6183051.,
      6195588., 7182812., 7197512., 7212212., 7226912., 8206996., 8223880.,
      8240764., 8257648., 7177667., 7192514., 7207361., 7222208., 6149157.,
      6161946., 6174735., 6187524., 5229738., 5240916., 5252094., 5263272.,
      6098064., 6111168., 6124272., 6137376., 6965256., 6980304., 6995352.,
      7010400., 6089622., 6102852., 6116082., 6129312., 5215266., 5226660.,
      5238054., 5249448.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      496952., 500720., 504488., 508256., 501512., 505328., 509144., 512960.,
      506072., 509936., 513800., 517664., 510632., 514544., 518456., 522368.,
      515192., 519152., 523112., 527072., 533432., 537584., 541736., 545888.,
      537992., 542192., 546392., 550592., 542552., 546800., 551048., 555296.,
      547112., 551408., 555704., 560000., 551672., 556016., 560360., 564704.,
      569912., 574448., 578984., 583520., 574472., 579056., 583640., 588224.,
      579032., 583664., 588296., 592928., 583592., 588272., 592952., 597632.,
      588152., 592880., 597608., 602336., 606392., 611312., 616232., 621152.,
      610952., 615920., 620888., 625856., 615512., 620528., 625544., 630560.,
      620072., 625136., 630200., 635264., 624632., 629744., 634856., 639968.,
      642872., 648176., 653480., 658784., 647432., 652784., 658136., 663488.,
      651992., 657392., 662792., 668192., 656552., 662000., 667448., 672896.,
      661112., 666608., 672104., 677600.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2613330., 2624724., 3051426., 3064656., 3490152., 3505200., 3055584.,
      3068688., 2620458., 2631636., 3080973., 3093762., 3596257., 3611104.,
      4111940., 4128824., 3598756., 3613456., 3085257., 3097794., 3551640.,
      3565680., 4144280., 4160576., 4736992., 4755520., 4144448., 4160576.,
      3551928., 3565680., 3086013., 3097794., 3599785., 3613456., 4113284.,
      4128824., 3597580., 3611104., 3082233., 3093762., 2621970., 2631636.,
      3057474., 3068688., 3492456., 3505200., 3053568., 3064656., 2615274.,
      2624724.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      252952., 254128., 255304., 256480., 257656., 258832., 260008., 261184.,
      262360., 263536., 271768., 272944., 274120., 275296., 276472., 277648.,
      278824., 280000., 281176., 282352., 290584., 291760., 292936., 294112.,
      295288., 296464., 297640., 298816., 299992., 301168., 309400., 310576.,
      311752., 312928., 314104., 315280., 316456., 317632., 318808., 319984.,
      328216., 329392., 330568., 331744., 332920., 334096., 335272., 336448.,
      337624., 338800.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5207868., 5226660., 5230548., 5249448., 6080802., 6102852., 6107136.,
      6129312., 6954960., 6980304., 6984912., 7010400., 6088866., 6111168.,
      6114948., 6137376., 5221692., 5240916., 5243940., 5263272., 6139014.,
      6161946., 6164466., 6187524., 7165613., 7192514., 7195160., 7222208.,
      8192968., 8223880., 8226568., 8257648., 7170317., 7197512., 7199570.,
      7226912., 6147078., 6170514., 6172026., 6195588., 7075920., 7103280.,
      7103856., 7131360., 8256472., 8288560., 8288896., 8321152., 9437120.,
      9473984., 9473984., 9511040., 8256472., 8288896., 8288560., 8321152.,
      7075920., 7103856., 7103280., 7131360., 6147078., 6172026., 6170514.,
      6195588., 7170317., 7199570., 7197512., 7226912., 8192968., 8226568.,
      8223880., 8257648., 7165613., 7195160., 7192514., 7222208., 6139014.,
      6164466., 6161946., 6187524., 5221692., 5243940., 5240916., 5263272.,
      6088866., 6114948., 6111168., 6137376., 6954960., 6984912., 6980304.,
      7010400., 6080802., 6107136., 6102852., 6129312., 5207868., 5230548.,
      5226660., 5249448.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      498416., 505904., 500720., 508256., 503024., 510608., 505328., 512960.,
      507632., 515312., 509936., 517664., 512240., 520016., 514544., 522368.,
      516848., 524720., 519152., 527072., 535280., 543536., 537584., 545888.,
      539888., 548240., 542192., 550592., 544496., 552944., 546800., 555296.,
      549104., 557648., 551408., 560000., 553712., 562352., 556016., 564704.,
      572144., 581168., 574448., 583520., 576752., 585872., 579056., 588224.,
      581360., 590576., 583664., 592928., 585968., 595280., 588272., 597632.,
      590576., 599984., 592880., 602336., 609008., 618800., 611312., 621152.,
      613616., 623504., 615920., 625856., 618224., 628208., 620528., 630560.,
      622832., 632912., 625136., 635264., 627440., 637616., 629744., 639968.,
      645872., 656432., 648176., 658784., 650480., 661136., 652784., 663488.,
      655088., 665840., 657392., 668192., 659696., 670544., 662000., 672896.,
      664304., 675248., 666608., 677600.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4830480., 4849272., 4868064., 4886856., 4857300., 4876200., 4895100.,
      4914000., 5623842., 5645892., 5667942., 5689992., 5654880., 5677056.,
      5699232., 5721408., 6413472., 6438816., 6464160., 6489504., 6448656.,
      6474144., 6499632., 6525120., 5596710., 5619012., 5641314., 5663616.,
      5627244., 5649672., 5672100., 5694528., 4783968., 4803192., 4822416.,
      4841640., 4809924., 4829256., 4848588., 4867920., 5588856., 5611788.,
      5634720., 5657652., 5618130., 5641188., 5664246., 5687304., 6501957.,
      6528858., 6555759., 6582660., 6535816., 6562864., 6589912., 6616960.,
      7409360., 7440272., 7471184., 7502096., 7447720., 7478800., 7509880.,
      7540960., 6460895., 6488090., 6515285., 6542480., 6494166., 6521508.,
      6548850., 6576192., 5518464., 5541900., 5565336., 5588772., 5546730.,
      5570292., 5593854., 5617416., 6309312., 6336672., 6364032., 6391392.,
      6340464., 6367968., 6395472., 6422976., 7334488., 7366576., 7398664.,
      7430752., 7370496., 7402752., 7435008., 7467264., 8351616., 8388480.,
      8425344., 8462208., 8392384., 8429440., 8466496., 8503552., 7276808.,
      7309232., 7341656., 7374080., 7312144., 7344736., 7377328., 7409920.,
      6210432., 6238368., 6266304., 6294240., 6240432., 6268512., 6296592.,
      6324672., 5258904., 5283852., 5308800., 5333748., 5284146., 5309220.,
      5334294., 5359368., 6107605., 6136858., 6166111., 6195364., 6136760.,
      6166160., 6195560., 6224960., 6947920., 6981520., 7015120., 7048720.,
      6980904., 7014672., 7048440., 7082208., 6047727., 6077274., 6106821.,
      6136368., 6076294., 6105988., 6135682., 6165376., 5156256., 5181708.,
      5207160., 5232612., 5180490., 5206068., 5231646., 5257224., 4264848.,
      4287096., 4309344., 4331592., 4284756., 4307112., 4329468., 4351824.,
      4947810., 4973892., 4999974., 5026056., 4970784., 4996992., 5023200.,
      5049408., 5622432., 5652384., 5682336., 5712288., 5648400., 5678496.,
      5708592., 5738688., 4888422., 4914756., 4941090., 4967424., 4910892.,
      4937352., 4963812., 4990272., 4163040., 4185720., 4208400., 4231080.,
      4182084., 4204872., 4227660., 4250448.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      989344.,  996832.,  1004320., 1011808., 993904.,  1001440., 1008976.,
      1016512., 998464.,  1006048., 1013632., 1021216., 1003024., 1010656.,
      1018288., 1025920., 1007584., 1015264., 1022944., 1030624., 1012144.,
      1019872., 1027600., 1035328., 1016704., 1024480., 1032256., 1040032.,
      1021264., 1029088., 1036912., 1044736., 1025824., 1033696., 1041568.,
      1049440., 1030384., 1038304., 1046224., 1054144., 1062304., 1070560.,
      1078816., 1087072., 1066864., 1075168., 1083472., 1091776., 1071424.,
      1079776., 1088128., 1096480., 1075984., 1084384., 1092784., 1101184.,
      1080544., 1088992., 1097440., 1105888., 1085104., 1093600., 1102096.,
      1110592., 1089664., 1098208., 1106752., 1115296., 1094224., 1102816.,
      1111408., 1120000., 1098784., 1107424., 1116064., 1124704., 1103344.,
      1112032., 1120720., 1129408., 1135264., 1144288., 1153312., 1162336.,
      1139824., 1148896., 1157968., 1167040., 1144384., 1153504., 1162624.,
      1171744., 1148944., 1158112., 1167280., 1176448., 1153504., 1162720.,
      1171936., 1181152., 1158064., 1167328., 1176592., 1185856., 1162624.,
      1171936., 1181248., 1190560., 1167184., 1176544., 1185904., 1195264.,
      1171744., 1181152., 1190560., 1199968., 1176304., 1185760., 1195216.,
      1204672., 1208224., 1218016., 1227808., 1237600., 1212784., 1222624.,
      1232464., 1242304., 1217344., 1227232., 1237120., 1247008., 1221904.,
      1231840., 1241776., 1251712., 1226464., 1236448., 1246432., 1256416.,
      1231024., 1241056., 1251088., 1261120., 1235584., 1245664., 1255744.,
      1265824., 1240144., 1250272., 1260400., 1270528., 1244704., 1254880.,
      1265056., 1275232., 1249264., 1259488., 1269712., 1279936., 1281184.,
      1291744., 1302304., 1312864., 1285744., 1296352., 1306960., 1317568.,
      1290304., 1300960., 1311616., 1322272., 1294864., 1305568., 1316272.,
      1326976., 1299424., 1310176., 1320928., 1331680., 1303984., 1314784.,
      1325584., 1336384., 1308544., 1319392., 1330240., 1341088., 1313104.,
      1324000., 1334896., 1345792., 1317664., 1328608., 1339552., 1350496.,
      1322224., 1333216., 1344208., 1355200.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5215266., 5226660., 5238054., 5249448., 6089622., 6102852., 6116082.,
      6129312., 6965256., 6980304., 6995352., 7010400., 6098064., 6111168.,
      6124272., 6137376., 5229738., 5240916., 5252094., 5263272., 6149157.,
      6161946., 6174735., 6187524., 7177667., 7192514., 7207361., 7222208.,
      8206996., 8223880., 8240764., 8257648., 7182812., 7197512., 7212212.,
      7226912., 6157977., 6170514., 6183051., 6195588., 7089240., 7103280.,
      7117320., 7131360., 8272264., 8288560., 8304856., 8321152., 9455456.,
      9473984., 9492512., 9511040., 8272768., 8288896., 8305024., 8321152.,
      7090104., 7103856., 7117608., 7131360., 6160245., 6172026., 6183807.,
      6195588., 7185899., 7199570., 7213241., 7226912., 8211028., 8226568.,
      8242108., 8257648., 7181636., 7195160., 7208684., 7222208., 6152937.,
      6164466., 6175995., 6187524., 5234274., 5243940., 5253606., 5263272.,
      6103734., 6114948., 6126162., 6137376., 6972168., 6984912., 6997656.,
      7010400., 6096048., 6107136., 6118224., 6129312., 5221098., 5230548.,
      5239998., 5249448.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      504728., 505904., 507080., 508256., 509432., 510608., 511784., 512960.,
      514136., 515312., 516488., 517664., 518840., 520016., 521192., 522368.,
      523544., 524720., 525896., 527072., 542360., 543536., 544712., 545888.,
      547064., 548240., 549416., 550592., 551768., 552944., 554120., 555296.,
      556472., 557648., 558824., 560000., 561176., 562352., 563528., 564704.,
      579992., 581168., 582344., 583520., 584696., 585872., 587048., 588224.,
      589400., 590576., 591752., 592928., 594104., 595280., 596456., 597632.,
      598808., 599984., 601160., 602336., 617624., 618800., 619976., 621152.,
      622328., 623504., 624680., 625856., 627032., 628208., 629384., 630560.,
      631736., 632912., 634088., 635264., 636440., 637616., 638792., 639968.,
      655256., 656432., 657608., 658784., 659960., 661136., 662312., 663488.,
      664664., 665840., 667016., 668192., 669368., 670544., 671720., 672896.,
      674072., 675248., 676424., 677600.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4163040., 4182084., 4185720., 4204872., 4208400., 4227660., 4231080.,
      4250448., 4888422., 4910892., 4914756., 4937352., 4941090., 4963812.,
      4967424., 4990272., 5622432., 5648400., 5652384., 5678496., 5682336.,
      5708592., 5712288., 5738688., 4947810., 4970784., 4973892., 4996992.,
      4999974., 5023200., 5026056., 5049408., 4264848., 4284756., 4287096.,
      4307112., 4309344., 4329468., 4331592., 4351824., 5156256., 5180490.,
      5181708., 5206068., 5207160., 5231646., 5232612., 5257224., 6047727.,
      6076294., 6077274., 6105988., 6106821., 6135682., 6136368., 6165376.,
      6947920., 6980904., 6981520., 7014672., 7015120., 7048440., 7048720.,
      7082208., 6107605., 6136760., 6136858., 6166160., 6166111., 6195560.,
      6195364., 6224960., 5258904., 5284146., 5283852., 5309220., 5308800.,
      5334294., 5333748., 5359368., 6210432., 6240432., 6238368., 6268512.,
      6266304., 6296592., 6294240., 6324672., 7276808., 7312144., 7309232.,
      7344736., 7341656., 7377328., 7374080., 7409920., 8351616., 8392384.,
      8388480., 8429440., 8425344., 8466496., 8462208., 8503552., 7334488.,
      7370496., 7366576., 7402752., 7398664., 7435008., 7430752., 7467264.,
      6309312., 6340464., 6336672., 6367968., 6364032., 6395472., 6391392.,
      6422976., 5518464., 5546730., 5541900., 5570292., 5565336., 5593854.,
      5588772., 5617416., 6460895., 6494166., 6488090., 6521508., 6515285.,
      6548850., 6542480., 6576192., 7409360., 7447720., 7440272., 7478800.,
      7471184., 7509880., 7502096., 7540960., 6501957., 6535816., 6528858.,
      6562864., 6555759., 6589912., 6582660., 6616960., 5588856., 5618130.,
      5611788., 5641188., 5634720., 5664246., 5657652., 5687304., 4783968.,
      4809924., 4803192., 4829256., 4822416., 4848588., 4841640., 4867920.,
      5596710., 5627244., 5619012., 5649672., 5641314., 5672100., 5663616.,
      5694528., 6413472., 6448656., 6438816., 6474144., 6464160., 6499632.,
      6489504., 6525120., 5623842., 5654880., 5645892., 5677056., 5667942.,
      5699232., 5689992., 5721408., 4830480., 4857300., 4849272., 4876200.,
      4868064., 4895100., 4886856., 4914000.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      994528.,  1009456., 996832.,  1011808., 999136.,  1014160., 1001440.,
      1016512., 1003744., 1018864., 1006048., 1021216., 1008352., 1023568.,
      1010656., 1025920., 1012960., 1028272., 1015264., 1030624., 1017568.,
      1032976., 1019872., 1035328., 1022176., 1037680., 1024480., 1040032.,
      1026784., 1042384., 1029088., 1044736., 1031392., 1047088., 1033696.,
      1049440., 1036000., 1051792., 1038304., 1054144., 1068256., 1084720.,
      1070560., 1087072., 1072864., 1089424., 1075168., 1091776., 1077472.,
      1094128., 1079776., 1096480., 1082080., 1098832., 1084384., 1101184.,
      1086688., 1103536., 1088992., 1105888., 1091296., 1108240., 1093600.,
      1110592., 1095904., 1112944., 1098208., 1115296., 1100512., 1117648.,
      1102816., 1120000., 1105120., 1122352., 1107424., 1124704., 1109728.,
      1127056., 1112032., 1129408., 1141984., 1159984., 1144288., 1162336.,
      1146592., 1164688., 1148896., 1167040., 1151200., 1169392., 1153504.,
      1171744., 1155808., 1174096., 1158112., 1176448., 1160416., 1178800.,
      1162720., 1181152., 1165024., 1183504., 1167328., 1185856., 1169632.,
      1188208., 1171936., 1190560., 1174240., 1192912., 1176544., 1195264.,
      1178848., 1197616., 1181152., 1199968., 1183456., 1202320., 1185760.,
      1204672., 1215712., 1235248., 1218016., 1237600., 1220320., 1239952.,
      1222624., 1242304., 1224928., 1244656., 1227232., 1247008., 1229536.,
      1249360., 1231840., 1251712., 1234144., 1254064., 1236448., 1256416.,
      1238752., 1258768., 1241056., 1261120., 1243360., 1263472., 1245664.,
      1265824., 1247968., 1268176., 1250272., 1270528., 1252576., 1272880.,
      1254880., 1275232., 1257184., 1277584., 1259488., 1279936., 1289440.,
      1310512., 1291744., 1312864., 1294048., 1315216., 1296352., 1317568.,
      1298656., 1319920., 1300960., 1322272., 1303264., 1324624., 1305568.,
      1326976., 1307872., 1329328., 1310176., 1331680., 1312480., 1334032.,
      1314784., 1336384., 1317088., 1338736., 1319392., 1341088., 1321696.,
      1343440., 1324000., 1345792., 1326304., 1348144., 1328608., 1350496.,
      1330912., 1352848., 1333216., 1355200.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, SAME3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6629724.,  6648768.,  6667812.,  6686856.,  6656544.,  6675696.,
      6694848.,  6714000.,  6683364.,  6702624.,  6721884.,  6741144.,
      6710184.,  6729552.,  6748920.,  6768288.,  7754502.,  7776972.,
      7799442.,  7821912.,  7785540.,  7808136.,  7830732.,  7853328.,
      7816578.,  7839300.,  7862022.,  7884744.,  7847616.,  7870464.,
      7893312.,  7916160.,  8884176.,  8910144.,  8936112.,  8962080.,
      8919360.,  8945472.,  8971584.,  8997696.,  8954544.,  8980800.,
      9007056.,  9033312.,  8989728.,  9016128.,  9042528.,  9068928.,
      7786758.,  7809732.,  7832706.,  7855680.,  7817292.,  7840392.,
      7863492.,  7886592.,  7847826.,  7871052.,  7894278.,  7917504.,
      7878360.,  7901712.,  7925064.,  7948416.,  6685020.,  6704928.,
      6724836.,  6744744.,  6710976.,  6730992.,  6751008.,  6771024.,
      6736932.,  6757056.,  6777180.,  6797304.,  6762888.,  6783120.,
      6803352.,  6823584.,  7987350.,  8011584.,  8035818.,  8060052.,
      8016624.,  8040984.,  8065344.,  8089704.,  8045898.,  8070384.,
      8094870.,  8119356.,  8075172.,  8099784.,  8124396.,  8149008.,
      9332295.,  9360862.,  9389429.,  9417996.,  9366154.,  9394868.,
      9423582.,  9452296.,  9400013.,  9428874.,  9457735.,  9486596.,
      9433872.,  9462880.,  9491888.,  9520896.,  10680264., 10713248.,
      10746232., 10779216., 10718624., 10751776., 10784928., 10818080.,
      10756984., 10790304., 10823624., 10856944., 10795344., 10828832.,
      10862320., 10895808., 9351111.,  9380266.,  9409421.,  9438576.,
      9384382.,  9413684.,  9442986.,  9472288.,  9417653.,  9447102.,
      9476551.,  9506000.,  9450924.,  9480520.,  9510116.,  9539712.,
      8019606.,  8044848.,  8070090.,  8095332.,  8047872.,  8073240.,
      8098608.,  8123976.,  8076138.,  8101632.,  8127126.,  8152620.,
      8104404.,  8130024.,  8155644.,  8181264.,  9368016.,  9398016.,
      9428016.,  9458016.,  9399168.,  9429312.,  9459456.,  9489600.,
      9430320.,  9460608.,  9490896.,  9521184.,  9461472.,  9491904.,
      9522336.,  9552768.,  10934280., 10969616., 11004952., 11040288.,
      10970288., 11005792., 11041296., 11076800., 11006296., 11041968.,
      11077640., 11113312., 11042304., 11078144., 11113984., 11149824.,
      12500928., 12541696., 12582464., 12623232., 12541696., 12582656.,
      12623616., 12664576., 12582464., 12623616., 12664768., 12705920.,
      12623232., 12664576., 12705920., 12747264., 10934280., 10970288.,
      11006296., 11042304., 10969616., 11005792., 11041968., 11078144.,
      11004952., 11041296., 11077640., 11113984., 11040288., 11076800.,
      11113312., 11149824., 9368016.,  9399168.,  9430320.,  9461472.,
      9398016.,  9429312.,  9460608.,  9491904.,  9428016.,  9459456.,
      9490896.,  9522336.,  9458016.,  9489600.,  9521184.,  9552768.,
      8019606.,  8047872.,  8076138.,  8104404.,  8044848.,  8073240.,
      8101632.,  8130024.,  8070090.,  8098608.,  8127126.,  8155644.,
      8095332.,  8123976.,  8152620.,  8181264.,  9351111.,  9384382.,
      9417653.,  9450924.,  9380266.,  9413684.,  9447102.,  9480520.,
      9409421.,  9442986.,  9476551.,  9510116.,  9438576.,  9472288.,
      9506000.,  9539712.,  10680264., 10718624., 10756984., 10795344.,
      10713248., 10751776., 10790304., 10828832., 10746232., 10784928.,
      10823624., 10862320., 10779216., 10818080., 10856944., 10895808.,
      9332295.,  9366154.,  9400013.,  9433872.,  9360862.,  9394868.,
      9428874.,  9462880.,  9389429.,  9423582.,  9457735.,  9491888.,
      9417996.,  9452296.,  9486596.,  9520896.,  7987350.,  8016624.,
      8045898.,  8075172.,  8011584.,  8040984.,  8070384.,  8099784.,
      8035818.,  8065344.,  8094870.,  8124396.,  8060052.,  8089704.,
      8119356.,  8149008.,  6685020.,  6710976.,  6736932.,  6762888.,
      6704928.,  6730992.,  6757056.,  6783120.,  6724836.,  6751008.,
      6777180.,  6803352.,  6744744.,  6771024.,  6797304.,  6823584.,
      7786758.,  7817292.,  7847826.,  7878360.,  7809732.,  7840392.,
      7871052.,  7901712.,  7832706.,  7863492.,  7894278.,  7925064.,
      7855680.,  7886592.,  7917504.,  7948416.,  8884176.,  8919360.,
      8954544.,  8989728.,  8910144.,  8945472.,  8980800.,  9016128.,
      8936112.,  8971584.,  9007056.,  9042528.,  8962080.,  8997696.,
      9033312.,  9068928.,  7754502.,  7785540.,  7816578.,  7847616.,
      7776972.,  7808136.,  7839300.,  7870464.,  7799442.,  7830732.,
      7862022.,  7893312.,  7821912.,  7853328.,  7884744.,  7916160.,
      6629724.,  6656544.,  6683364.,  6710184.,  6648768.,  6675696.,
      6702624.,  6729552.,  6667812.,  6694848.,  6721884.,  6748920.,
      6686856.,  6714000.,  6741144.,  6768288.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow5Stride1, VALID3x8x8x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1974128., 1989056., 2003984., 2018912., 1978688., 1993664., 2008640.,
      2023616., 1983248., 1998272., 2013296., 2028320., 1987808., 2002880.,
      2017952., 2033024., 1992368., 2007488., 2022608., 2037728., 1996928.,
      2012096., 2027264., 2042432., 2001488., 2016704., 2031920., 2047136.,
      2006048., 2021312., 2036576., 2051840., 2010608., 2025920., 2041232.,
      2056544., 2015168., 2030528., 2045888., 2061248., 2019728., 2035136.,
      2050544., 2065952., 2024288., 2039744., 2055200., 2070656., 2028848.,
      2044352., 2059856., 2075360., 2033408., 2048960., 2064512., 2080064.,
      2037968., 2053568., 2069168., 2084768., 2042528., 2058176., 2073824.,
      2089472., 2047088., 2062784., 2078480., 2094176., 2051648., 2067392.,
      2083136., 2098880., 2056208., 2072000., 2087792., 2103584., 2060768.,
      2076608., 2092448., 2108288., 2120048., 2136512., 2152976., 2169440.,
      2124608., 2141120., 2157632., 2174144., 2129168., 2145728., 2162288.,
      2178848., 2133728., 2150336., 2166944., 2183552., 2138288., 2154944.,
      2171600., 2188256., 2142848., 2159552., 2176256., 2192960., 2147408.,
      2164160., 2180912., 2197664., 2151968., 2168768., 2185568., 2202368.,
      2156528., 2173376., 2190224., 2207072., 2161088., 2177984., 2194880.,
      2211776., 2165648., 2182592., 2199536., 2216480., 2170208., 2187200.,
      2204192., 2221184., 2174768., 2191808., 2208848., 2225888., 2179328.,
      2196416., 2213504., 2230592., 2183888., 2201024., 2218160., 2235296.,
      2188448., 2205632., 2222816., 2240000., 2193008., 2210240., 2227472.,
      2244704., 2197568., 2214848., 2232128., 2249408., 2202128., 2219456.,
      2236784., 2254112., 2206688., 2224064., 2241440., 2258816., 2265968.,
      2283968., 2301968., 2319968., 2270528., 2288576., 2306624., 2324672.,
      2275088., 2293184., 2311280., 2329376., 2279648., 2297792., 2315936.,
      2334080., 2284208., 2302400., 2320592., 2338784., 2288768., 2307008.,
      2325248., 2343488., 2293328., 2311616., 2329904., 2348192., 2297888.,
      2316224., 2334560., 2352896., 2302448., 2320832., 2339216., 2357600.,
      2307008., 2325440., 2343872., 2362304., 2311568., 2330048., 2348528.,
      2367008., 2316128., 2334656., 2353184., 2371712., 2320688., 2339264.,
      2357840., 2376416., 2325248., 2343872., 2362496., 2381120., 2329808.,
      2348480., 2367152., 2385824., 2334368., 2353088., 2371808., 2390528.,
      2338928., 2357696., 2376464., 2395232., 2343488., 2362304., 2381120.,
      2399936., 2348048., 2366912., 2385776., 2404640., 2352608., 2371520.,
      2390432., 2409344., 2411888., 2431424., 2450960., 2470496., 2416448.,
      2436032., 2455616., 2475200., 2421008., 2440640., 2460272., 2479904.,
      2425568., 2445248., 2464928., 2484608., 2430128., 2449856., 2469584.,
      2489312., 2434688., 2454464., 2474240., 2494016., 2439248., 2459072.,
      2478896., 2498720., 2443808., 2463680., 2483552., 2503424., 2448368.,
      2468288., 2488208., 2508128., 2452928., 2472896., 2492864., 2512832.,
      2457488., 2477504., 2497520., 2517536., 2462048., 2482112., 2502176.,
      2522240., 2466608., 2486720., 2506832., 2526944., 2471168., 2491328.,
      2511488., 2531648., 2475728., 2495936., 2516144., 2536352., 2480288.,
      2500544., 2520800., 2541056., 2484848., 2505152., 2525456., 2545760.,
      2489408., 2509760., 2530112., 2550464., 2493968., 2514368., 2534768.,
      2555168., 2498528., 2518976., 2539424., 2559872., 2557808., 2578880.,
      2599952., 2621024., 2562368., 2583488., 2604608., 2625728., 2566928.,
      2588096., 2609264., 2630432., 2571488., 2592704., 2613920., 2635136.,
      2576048., 2597312., 2618576., 2639840., 2580608., 2601920., 2623232.,
      2644544., 2585168., 2606528., 2627888., 2649248., 2589728., 2611136.,
      2632544., 2653952., 2594288., 2615744., 2637200., 2658656., 2598848.,
      2620352., 2641856., 2663360., 2603408., 2624960., 2646512., 2668064.,
      2607968., 2629568., 2651168., 2672768., 2612528., 2634176., 2655824.,
      2677472., 2617088., 2638784., 2660480., 2682176., 2621648., 2643392.,
      2665136., 2686880., 2626208., 2648000., 2669792., 2691584., 2630768.,
      2652608., 2674448., 2696288., 2635328., 2657216., 2679104., 2700992.,
      2639888., 2661824., 2683760., 2705696., 2644448., 2666432., 2688416.,
      2710400.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}